Learn to use
QuantConnect
and Explore
Features

WRITING ALGORITHMS

Learn tools you need
to build algorithmic
trading strategies

Build on a mature, flexible,
feature-complete API managing
billions of dollars capital, and used
by 5,000+ investors every month.

Table of Content

Key Concepts

Key Concepts > Getting Started

Introduction

Quantitative trading is a method of trading where computer programs execute a set of defined trading rules in an automated fashion. Quants take a scientific approach to trading, applying concepts from mathematics, time series analysis, statistics, computer science, and machine learning. Compared to discretionary traders, quants can respond faster to new information and are at less risk to their emotions during trades. Since quants can concurrently trade many strategies while discretionary traders only have the mental bandwidth to trade a small number of concurrent strategies, quant traders can have more diversified portfolios.

Learn Programming

We aim to make it as easy as possible to use QuantConnect, but you still need to be able to program. The following table provides some resources to get you started:

Enroll in Bootcamp

Bootcamp is an online coding experience where QuantConnect team and community members teach you to write your first algorithms. Bootcamp gives you step-by-step instructions on practical and beginner-friendly topics, so it's a great way to learn LEAN. The lessons cover many topics that you use as you write your own algorithms, including universe selection , indicators , and consolidators . To get started, check out the course library .

Example Algorithm

The following video demonstrates how to implement an algorithm that buys and holds an S&P 500 index ETF:

// Import all the functionality you need to run algorithms
using QuantConnect.Data;

// Define a trading algorithm that is a subclass of QCAlgorithm
namespace QuantConnect.Algorithm.CSharp
{
    public class MyAlgorithm : QCAlgorithm
    {
        // Define an Initialize method.
        // This method is the entry point of your algorithm where you define a series of settings.
        // LEAN only calls this method one time, at the start of your algorithm.
        public override void Initialize()
        {
            // Set the start and end dates
            SetStartDate(2018, 1, 1);
            SetEndDate(2022, 6, 1);
            // Set the starting cash balance to $100,000 USD
            SetCash(100000);
            // Add data for the S&P500 index ETF
            AddEquity("SPY");
        }

        // Define an OnData method. 
        // This method receives all the data you subscribe to in discrete time slices.
        // It's where you make trading decisions.
        public override void OnData(Slice slice)
        {
            // Allocate 100% of the portfolio to SPY
            if (!Portfolio.Invested)
            {
                SetHoldings("SPY", 1);
            }
        }
    }
}

# Import all the functionality you need to run algorithms
from AlgorithmImports import *
        
# Define a trading algorithm that is a subclass of QCAlgorithm
class MyAlgorithm(QCAlgorithm):
    # Define an Initialize method.
    # This method is the entry point of your algorithm where you define a series of settings.
    # LEAN only calls this method one time, at the start of your algorithm.
    def initialize(self) -> None:
        # Set start and end dates
        self.set_start_date(2018, 1, 1)
        self.set_end_date(2022, 6, 1)
        # Set the starting cash balance to $100,000 USD
        self.set_cash(100000)
        # Add data for the S&P500 index ETF
        self.add_equity("SPY")
        
    # Define an OnData method. 
    # This method receives all the data you subscribe to in discrete time slices.
    # It's where you make trading decisions.
    def on_data(self, slice: Slice) -> None:
        # Allocate 100% of the portfolio to SPY
        if not self.portfolio.invested:
            self.set_holdings("SPY", 1)

Key Concepts > Algorithm Engine

Introduction

LEAN Engine is an open-source algorithmic trading engine built for easy strategy research, backtesting, and live trading. We integrate with common data providers and brokerages, so you can quickly deploy algorithmic trading strategies. The core of the LEAN Engine is written in C#, but it operates seamlessly on Linux, Mac and Windows operating systems. To use it, you can write algorithms in Python 3.11 or C#. QuantConnect maintains the LEAN project and uses it to drive the web-based algorithmic trading platform on the website.

Since LEAN is open-source, you aren't locked-in to the QuantConnect platform. You can run LEAN with your own infrastructure, data, and brokerage connections. If you use QuantConnect, our team of engineers manage the infrastructure, you can run the latest version of LEAN with all of its brokerage connections, and you can utilize the datasets in the Dataset Market .

Your Algorithm and LEAN

To create a trading algorithm with LEAN, define a subclass of the QCAlgorithm class. LEAN loads your algorithm into the engine during the building and compilation process. LEAN runs an algorithm manager that synchronizes the data your algorithm requests, injects the data into your algorithm so you can place trades, processes your orders, and then updates your algorithm state.

The LEAN engine manages your portfolio and data feeds, so you focus on your algorithm strategy and execution. We automatically provide basic portfolio management and reality modeling underneath the hood. The QCAlgorithm class provides some key helper properties for you to use, including the Security Manager, Portfolio Manager, Transactions Manager, Notification Manager, and Scheduling Manager. The class also has hundreds of helper methods to make the API easy to use.

The Securities property is a dictionary of Security objects. Each asset (Equity, Forex pair, etc) in your algorithm has a Security object. All the models for a security live on these objects. For example, Securities["IBM"].FeeModel and Securities["IBM"].Price self.Securities["IBM"].FeeModel and self.Securities["IBM"].Price return the fee model and price of IBM, respectively.

The Portfolio is a dictionary of SecurityHolding objects. These classes track the profits, losses, fees, and quantity of individual portfolio holdings. For example, Portfolio["IBM"].LastTradeProfit self.portfolio["IBM"].last_trade_profit returns the profit of your last IBM trade.

Other helpers like Transactions , Schedule , Notify , and Universe have their own helper methods.

public class QCAlgorithm
{
    SecurityManager Securities;               // Array of Security objects.
    SecurityPortfolioManager Portfolio;       // Array of SecurityHolding objects
    SecurityTransactionManager Transactions;  // Transactions helper
    ScheduleManager Schedule;                 // Scheduling helper
    NotificationManager Notify;               // Email, SMS helper
    UniverseManager Universe;                 // Universe helper

    // Set up Requested Data, Cash, Time Period.
    public virtual void Initialize() { ... };

    // Event Handlers:
    public virtual void OnData(Slice slice) { ... };
    public virtual void OnEndOfDay(Symbol symbol) { ... };
    public virtual void OnEndOfAlgorithm() { ... };

    // Indicator Helpers
    public SimpleMovingAverage SMA(Symbol symbol, int period) { ... };
}

class QCAlgorithm:
    securities   # Array of Security objects.
    portfolio    # Array of SecurityHolding objects
    transactions # Transactions helper
    schedule     # Scheduling helper
    notify       # Email, SMS helper
    universe     # Universe helper

    # Set up Requested Data, Cash, Time Period.
    def initialize(self) -> None:

    # Other Event Handlers
    def on_data(self, slice: Slice) -> None:
    def on_end_of_day(self, symbol: Symbol) -> None:
    def on_end_of_algorithm(self) -> None:

    # Indicator Helpers
    def sma(self, symbol: Symbol, period: int) -> SimpleMovingAverage:

Only define one algorithm class per project. To trade multiple strategies in a single algorithm, implement an Algorithm Framework design with multiple Alpha models . To be notified when you can define more than one algorithm class per project, subscribe to GitHub Issue #6968 .

Threads in LEAN

LEAN is multi-threaded and attempts to consume as much CPU as possible to perform given work as quickly as possible. The analysis engine loads data parallel and synchronizes it to generate the requested security information.

The client algorithm is plugged into LEAN, and has its events triggered synchronously in backtesting. The primary bottle neck to LEAN execution is executing client code.

In live trading, most events are synchronous as in backtesting, however order events are triggered immediately from the brokerage thread (asynchronously) to ensure the lowest latency. For example; a strategy using hourly data, with a limit order could fill between data bars. This fill event is triggered when it occurs in live trading.

We recommend using thread safe collections when possible, or locks around collections to ensure they are thread-safe.

Batch vs Stream Analysis

Backtesting platforms come in two general varieties, batch processing and event streaming. Batch processing backtesting is much simpler. It loads all data into an array and passes it to your algorithm for analysis. Because your algorithm has access to future data points, it is easy to introduce look-ahead bias . Most home-grown analysis tools are batch systems.

QuantConnect/LEAN is a streaming analysis system. In live trading, your algorithm receives data points one after another over time. QuantConnect models this in backtesting, streaming data to your algorithm in fast-forward mode. Because of this, you can't access price data beyond the Time Frontier . Although streaming analysis is slightly trickier to understand, it allows your algorithm to seamlessly work in backtests and live trading with no code changes.

Event Flow

When you deploy an algorithm, LEAN first calls the Initialize initialize method. In live mode, the engine loads your holdings and open orders from your brokerage account to add data subscriptions and populate the Securities securities , Portfolio portfolio , and Transactions transactions objects. LEAN receives the data from the subscriptions, synchronizes the data to create a timeslice , and then performs the following steps. Your algorithm can spend up to 10 minutes on each timeslice unless you call the Train train method.

1. If it's a backtest, check if there are Scheduled Events in the past that didn't fire because there was no data between the previous slice and the current slice. LEAN automatically creates a Scheduled Event to call the OnEndOfDay on_end_of_day method at the end of each day.

In live mode, Scheduled Events occur in a separate thread from the algorithm manager, so they run at the correct time.

2. Update the algorithm time.
3. Update the CurrentSlice current_slice .
4. Pass the SymbolChangedEvents to the OnSymbolChangedEvents on_symbol_changed_events method.
5. Cancel all open orders for securities that changed their ticker .
6. Add a Security object to the Securities securities collection for each new security in the universe.
7. Update the Security objects with the latest data.
8. Update the Cash objects in the CashBook with the latest data.
9. Process fill models for non-market orders.
   
10. Submit market on open orders to liquidate Equity Option contracts if the underlying Equity has a split warning .
11. Process margin calls .
    
12. If it's time to settle unsettled cash , perform settlement.
13. Call the OnSecuritiesChanged on_securities_changed method with the latest security changes.
14. Apply dividends to the portfolio.
15. For securities that have a split warning, update their portfolio holdings and adjust their open orders to account for the split.
16. Update consolidators with the latest data.
    
17. Pass custom data to the OnData on_data method.
18. Pass the Dividends to the OnDividends on_dividends method.
19. Pass the Splits to the OnSplits on_splits method.
20. Pass the Delistings to the OnDelistings on_delistings method.
21. Pass the Slice to the OnData on_data method.
22. Perform universe selection .
23. Pass the Slice to the Update update method of each Alpha model .
24. Pass the Insight objects from the Alpha model to the Portfolio Construction model .
25. Pass the PortfolioTarget objects from the Portfolio Construction model to each Risk Management model .
26. Pass the risk-adjusted PortfolioTarget objects from the Risk Management models to the Execution model .

When your algorithm stops executing, LEAN calls the OnEndOfAlgorithm on_end_of_algorithm method .

Python Support

The LEAN engine is written in C#, but you can create algorithms in C# or Python. If you program in Python, LEAN uses Python.Net to bridge between the C# engine and your algorithm. As a result of the bridge, QCAlgorithm class members are in camel case, not snake case. It can be slow to move from Python to C#. If you access C# objects in your Python algorithm, it's fastest to only access them once and save a reference if you need to access them again.

# Do this:
security_holding = self.portfolio[self._symbol]
avg_price = security_holding.average_price
quantity = security_holding.quantity

# Avoid this:
avg_price = self.portfolio[self._symbol].average_price
quantity = self.portfolio[self._symbol].quantity

Key Concepts > Multi-Asset Modeling

Introduction

We designed LEAN as a multi-asset platform with out-of-the-box support for multiple securities, so you can model complex portfolios like hedge funds.

Asset Portfolio

The portfolio manages the individual securities it contains. It tracks the cost of holding each security. It aggregates the performance of the individual securities in the portfolio to produce statistics like net profit and drawdown . The portfolio also holds information about each currency in its cashbook.

Cashbooks

We designed LEAN to be a multi-currency platform. LEAN can trade Forex, Cryptocurrencies, and other assets that are quoted in other currencies. A benefit of supporting multiple currencies is that as we add new asset classes from new countries, LEAN is already prepared to transact in those assets by using their quote currency. For instance, we added the India Equity market, which quotes assets in the INR currency.

The portfolio manages your currencies in its cashbook, which models the cash as a ledger of transactions. When you buy assets, LEAN uses the currencies in your cashbook to purchase the asset and pay the transaction fees. For more information about the cashbook, see Cashbook .

Buying Power

We model the margin requirements of each asset and reflect that in the buying power available to the algorithm. We source Futures margins from CME SPAN margins. Equity margin is 2x for standard margin accounts and 4x intraday for Pattern Day Trading accounts. For more information about buying power modeling, see Buying Power .

Key Concepts > Time Modeling

Key Concepts > Time Modeling > Periods

Introduction

Data comes in two different "shapes" according to the time period it covers: point values or period values. In QuantConnect, ticks are point values, and bars are a period values. These data formats have different properties, which control when LEAN emits them into your algorithm.

Start and End Time

Bars have a start and end time that represent the time period of which the bar aggregates data. LEAN passes the bar to your algorithm at the end time so that you don't receive the bar before it was actually available. Free online data providers commonly timestamp their bars to the start time of the bar and include the bar close price, making your research prone to look ahead bias.

Carefully consider the end-time of data to avoid one-off errors when you import the data into QC or compare indicator values across different platforms. Generally, bar timestamps can be represented as follows: bar.EndTime = bar.Time + bar.Period bar.end_time = bar.time + bar.period .

Period Values

Bars aggregate data across a period of time into a single object. We make this easy for you by pre-aggregating billions of raw trade-ticks into TradeBar objects and quote-ticks into QuoteBar objects.

We don't know the close of a bar until the start of the next bar, which can sometimes be confusing. For example, a price bar for Friday will include all the ticks from Friday 00:00:00 to Friday 23:59:59.99999, but LEAN will emit it to your algorithm on Saturday at midnight. As a result, if you analyze the Friday data and then place an order, LEAN sends the order to your brokerage on Saturday.

When there are no ticks during a period, LEAN emits the previous bar. This is the default behavior for bar data and it's referred to as "filling the data forward". You can enable and disable this setting when you create the security subscription .

We provide bar data in second, minute, hour, and daily bar formats. To create other periods of bars, see Consolidating Data .

Daily Periods

LEAN emits daily bars at midnight. To be notified when a security has finished trading for the day, add an OnEndOfDay on_end_of_day method to your algorithm. LEAN calls this method for each security every day.

def on_end_of_day(self, symbol: Symbol) -> None:
    pass

public override void OnEndOfDay(Symbol symbol)
{
    
}

Point Values

Point values have no period because they occur at a singular point in time. Examples of point data includes ticks, open interest, and news releases. Tick data represents a single trade or quote in the market. It's a discrete event with no period, so the Time time and EndTime end_time properties are the same. LEAN emits ticks as soon as they arrive and doesn't fill them forward.

Key Concepts > Time Modeling > Timeslices

Introduction

The core technology behind QuantConnect algorithmic trading is an event-based, streaming analysis system called LEAN . LEAN attempts to model the stream of time as accurately as possible, presenting data ("events") to your algorithms in the order it arrives, as you would experience in reality.

All QuantConnect algorithms have this time-stream baked in as the primary event handler, OnData on_data . The Slice object this method receives represents all of the data at a moment of time, a time-slice . No matter what data you request, you receive it in the order created according to simulated algorithm time. By only letting your algorithm see the present and past moments, we can prevent the most common quantitative-analysis error, look-ahead bias .

Time Frontier

If you request data for multiple securities and multiple resolutions, it can create a situation where one of your data subscriptions is ready to emit, but another subscription with a longer period is still be constructing its bar. Furthermore, if you request multiple datasets that have different time zones, your algorithm will receive the daily bars of each dataset at midnight in the respective time zone. To coordinate the data in these situations, we use the EndTime end_time of each data point to signal when LEAN should transmit it to your algorithm.

Once your algorithm reaches the EndTime end_time of a data point, LEAN sends the data to your OnData on_data method. For bar data, this is the beginning of the next period. To avoid look-ahead bias, you can only access data from before this Time Frontier. The Time time property of your algorithm is always equal to the Time Frontier.

Properties

Slice objects have the following properties:

Get Time Slices

To get the current Slice object, define an OnData on_data method or use the CurrentSlice current_slice property of your algorithm. The Slice contains all the data for a given moment in time. The Bars bars and QuoteBars quote_bars properties are Symbol /string indexed dictionaries. The Ticks ticks property is a list of ticks for that moment of time, indexed by the Symbol . To check which data formats are available for each asset class, see the Data Formats page in the Asset Classes chapter.

The Slice object gives you the following ways to access your data:

• Indexing the Slice , which returns a dynamic object of your type.

def on_data(self, slice: Slice) -> None:
    data = slice[self._symbol]

public override void OnData(Slice slice)
{
    var data = slice[_symbol];
}

With minute and second resolution data, the dynamic type is TradeBar for Equities and QuoteBar for other asset classes.

• Indexing the static properties, which returns the type you specify.

def on_data(self, slice: Slice) -> None:
    trade_bar = slice.bars[self._symbol]
    quote_bar = slice.quote_bars[self._symbol]

public override void OnData(Slice slice)
{
    var tradeBars = slice.Bars[_symbol];
    var quoteBars = slice.QuoteBars[_symbol];
}

• Calling the Get<T>() helper method.

public override void OnData(Slice slice)
{
    var tradeBar = slice.Get<TradeBar>(_symbol);
    var quoteBar = slice.Get<QuoteBar>(_symbol);
    var ticks = slice.Get<Ticks>(_symbol);
}

Strongly typed access gives you compile-time safety, but dynamic type access can sometimes simplify coding. We recommend static types since they are easier to debug.

Check if the Slice contains the data you're looking for before you index it. If there is little trading, or you are in the same time loop as when you added the security, it may not have any data. Even if you enabled fill-forward for a security subscription, you should check if the data exists in the dictionary before you try to index it. To check if the Slice contains for a security, call the ContainsKey contains_key method. Note: if the Slice object doesn't contain any market data but it contains auxiliary data, the slice.ContainsKey(symbol) slice.contains_key(symbol) method can return true while slice[symbol] returns None null .

def on_data(self, slice: Slice) -> None:
    if slice.contains_key(self._symbol) and slice[self._symbol]:
        data = slice[self._symbol]

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var data = slice[_symbol];
    }
}

Key Concepts > Time Modeling > Time Zones

Introduction

LEAN is an international trading engine, so it can operate across time zones. The exchange, your algorithm, and the data in your algorithm can all have different time zones.

Exchange Time Zone

Exchanges are located in different areas, so they can have different time zones. To get the time zone of the exchange that a Security trades on, use its Exchange.Hours.TimeZone exchange.hours.time_zone property.

var timeZone = Securities[_symbol].Exchange.Hours.TimeZone;

time_zone = self.securities[self._symbol].exchange.hours.time_zone

Algorithm Time Zone

LEAN supports international trading across multiple time zones and markets, so it needs a reference time zone for the algorithm to set the Time time . The default time zone is Eastern Time (ET), which is UTC-4 in summer and UTC-5 in winter. To set a different time zone, call the SetTimeZone set_time_zone method. This method accepts either a string following the IANA Time Zone database convention or a NodaTime .DateTimeZone object. If you pass a string, the method converts it to a NodaTime.DateTimeZone object. The TimeZones class provides the following helper attributes to create NodaTime.DateTimeZone objects:

SetTimeZone("Europe/London");
SetTimeZone(NodaTime.DateTimeZone.Utc);
SetTimeZone(TimeZones.Chicago);

self.set_time_zone("Europe/London")
self.set_time_zone(TimeZones.CHICAGO)

To get the time zone of your algorithm, use the TimeZone time_zone property.

time_zone = self.time_zone

var timeZone = TimeZone;

To get the algorithm time in Coordinated Universal Time (UTC), use the UtcTime utc_time property.

utc_time = self.utc_time

var utcTime = UtcTime;

The Time time and UtcTime utc_time objects have no time zone. LEAN maintains their state to be consistent.

Data Time Zone

Datasets can have different time zones because the time zone is up to the data provider, where they are located, and where they collect the data. LEAN tracks the time zone of each dataset so that you receive the correct data at the right point in time in your algorithm. If you have multiple datasets in your algorithm from different time zones, LEAN synchronizes them to your algorithm time. Furthermore, if you set up time period consolidators , LEAN consolidates the data based on the data time zone.

To get the time zone of a dataset, view the listing page in the Dataset Market or call the GetDataTimeZone method.

time_zone = self.market_hours_database.get_data_time_zone(Market.USA, self.symbol, SecurityType.EQUITY)

var timeZone = MarketHoursDatabase.GetDataTimeZone(Market.USA, _symbol, SecurityType.Equity);

Key Concepts > Security Identifiers

Introduction

We implemented Symbol objects in the LEAN open-source project as a way to identify or "finger-print" tradable assets so that no further database look-up is required. All QuantConnect and LEAN Algorithm API methods use Symbol objects to identify assets.

Encoding Symbols

SecurityIdentifier objects have several public properties to uniquely identify each asset. The following table describes these properties:

We encode the preceding properties to create Symbol objects. We do our best to hide the details of this process from your algorithm, but you'll occasionally see it come through as an encoded hash like AAPL R735QTJ8XC9X . The first half of the encoded string represents the first ticker AAPL was listed under. The other letters at the end of the string represent the serialized form of the preceding SecurityIdentifier properties. You may also see an encoded has like AAPL XL7X5I241SO6|AAPL R735QTJ8XC9X for a derivative contract. In this case, the part before the | is contract hash and the part after the | is the underlying hash. This serialization approach lets LEAN assign a short, unique string to octillions of different security objects.

LEAN assumes the ticker you pass to the AddEquity add_equity method is the current ticker of the Equity asset. To access this ticker, use the Value value property of the Symbol object.

self._symbol = self.add_equity("GOOG").symbol
self.debug(self._symbol.id.value) # Prints "GOOCV"
self.debug(self._symbol.value)    # Prints "GOOG"
self.debug(str(self._symbol.id))  # Prints "GOOCV VP83T1ZUHROL"

var symbol = AddEquity("GOOG").Symbol;
Debug(symbol.ID.Value);       // Prints "GOOCV"
Debug(symbol.Value);          // Prints "GOOG"
Debug(symbol.ID.ToString());  // Prints "GOOCV VP83T1ZUHROL"

If you create the security subscription with a universe selection function, the Value value property of the Symbol object is the point-in-time ticker.

Decoding Symbols

When a SecurityIdentifier is serialized to a string, it looks something like SPY R735QTJ8XC9X . This two-part string is a base64 encoded set of data. Encoding all of the properties into a short format allows dense communication without requiring a third-party list or look-up. Most of the time, you will not need to work with these encoded strings. However, to deserialize the string into a Symbol object, call the Symbol symbol method.

var symbol = Symbol("GOOCV VP83T1ZUHROL");
symbol.ID.Market;     // => "USA"
symbol.SecurityType;  // => SecurityType.Equity
symbol.Value;         // => "GOOCV"

symbol = self.symbol("GOOCV VP83T1ZUHROL")
symbol.id.market      # => "USA"
symbol.security_type  # => SecurityType.EQUITY
symbol.value          # => "GOOCV"

The Market market property distinguishes between tickers that have the same string value but represent different underlying assets. A prime example of this is the various market makers who have different prices for EURUSD. We store this data separately and as they have different fill prices, we treat the execution venues as different markets.

Tickers

Tickers are a string shortcode representation for an asset. Some examples of popular tickers include "AAPL" for Apple Corporation and "IBM" for International Business Machines Corporation. These tickers often change when the company rebrands or they undergo a merger or reverse merger.

The ticker of an asset is not the same as the Symbol . Symbol objects are permanent and track the underlying entity. When a company rebrands or changes its name, the Symbol object remains constant, giving algorithms a way to reliably track assets over time.

Tickers are also often reused by different brokerages. For example Coinbase, a leading US Crypto Brokerage lists the "BTCUSD" ticker for trading. Its competitor, Bitfinex, also lists "BTCUSD". You can trade both tickers with LEAN. Symbol objects allow LEAN to identify which market you reference in your algorithms.

To create a Symbol object for a point-in-time ticker, call the GenerateEquity generate_equity method to create the security identifier and then call the Symbol constructor. For example, Heliogen, Inc. changed their ticker from ATHN to HLGN on December 31, 2021. To convert the ATHN ticker to the Equity Symbol , type:

ticker = "ATHN"
security_id = SecurityIdentifier.generate_equity(ticker, Market.USA, mapping_resolve_date=datetime(2021, 12, 1))
symbol = Symbol(security_id, ticker)

var ticker = "ATHN";
var securityID = SecurityIdentifier.GenerateEquity(ticker, Market.USA, mappingResolveDate:new DateTime(2021, 12, 1));
var symbol = new Symbol(securityID, ticker);

In the preceding code snippet, the mappingResolveDate mapping_resolve_date must be a date when the point-in-time ticker was trading.

Symbol Cache

To make using the API easier, we have built the Symbol Cache technology, which accepts strings and tries to guess which Symbol object you might mean. With the Symbol Cache, many methods can accept a string such as "IBM" instead of a complete Symbol object. We highly recommend you don't rely on this technology and instead save explicit references to your securities when you need them.

# Example 1: Relying On Symbol Cache:
self.add_equity("IBM")          # Add by IBM string ticker, save reference to Symbol Cache.
self.market_order("IBM", 100)   # Determine refering to IBM Equity from Symbol Cache.
self.history("AAPL", 14)        # Makes a guess referring to AAPL Equity.

# Example 2: Correctly Using Symbols: 
self.ibm = self.add_equity("IBM").symbol   # Add IBM Equity string ticker, save Symbol.
self.market_order(self.ibm, 100)           # Use IBM Symbol in future API calls.

self.aapl = Symbol.create("AAPL", SecurityType.EQUITY, Market.USA)
self.history(self.aapl, 14)

// Example 1: Relying On Symbol Cache:
AddEquity("IBM");          // Add by IBM string ticker, save reference to Symbol Cache.
MarketOrder("IBM", 100);   // Determine refering to IBM Equity from Symbol Cache.
History("AAPL", 14);       // Guess referring to AAPL Equity.

// Example 2: Correctly Using Symbols: 
var ibm = AddEquity("IBM").Symbol;   // Add IBM Equity string ticker, save Symbol.
MarketOrder(ibm, 100);               // Use IBM Symbol in future API calls.

var aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
History(aapl, 14);

Industry Standard Identifiers

You can convert industry-standard security identifiers like CUSIP, FIGI, ISIN, and SEDOL to Symbol objects and you can convert Symbol objects to industry-standard security identifiers.

CUSIP

To convert a Committee on Uniform Securities Identification Procedures (CUSIP) number to a Symbol or a Symbol to a CUSIP number, call the CUSIP cusip method.

symbol = self.cusip("03783310") # AAPL Symbol
cusip = self.cusip(symbol) # AAPL CUSIP (03783310)

var symbol = CUSIP("03783310"); // AAPL Symbol
var cusip = CUSIP(symbol); // AAPL CUSIP (03783310)

FIGI

To convert a Financial Instrument Global Identifier (FIGI) to a Symbol or a Symbol to a FIGI, call the CompositeFIGI composite_figi method.

symbol = self.composite_figi("BBG000B9XRY4") # AAPL Symbol
figi = self.composite_figi(symbol) # AAPL FIGI (BBG000B9XRY4)

var symbol = CompositeFIGI("BBG000B9XRY4"); // AAPL Symbol
var figi = CompositeFIGI(symbol); // AAPL FIGI (BBG000B9XRY4)

ISIN

To convert an International Securities Identification Number (ISIN) to a Symbol or a Symbol to an ISIN, call the ISIN isin method.

symbol = self.isin("US0378331005") # AAPL Symbol
isin = self.isin(symbol) # AAPL ISIN (US0378331005)

var symbol = ISIN("US0378331005"); // AAPL Symbol
var isin = ISIN(symbol); // AAPL ISIN (US0378331005)

SEDOL

To convert a Stock Exchange Daily Official List (SEDOL) number to a Symbol or a Symbol to a SEDOL number, call the SEDOL sedol method.

symbol = self.sedol("2046251") # AAPL Symbol
sedol = self.sedol(symbol) # AAPL SEDOL (2046251)

var symbol = SEDOL("2046251"); // AAPL Symbol
var sedol = SEDOL(symbol); // AAPL SEDOL (2046251)

Key Concepts > Event Handlers

Introduction

Event handlers are called during an algorithm execution to pass information to your strategy. Most of the events are not needed for simple strategies, but can be helpful for debugging issues in more complex algorithms.

Data Events

public override void OnData(Slice slice)
{
    slice.TryGetValue(_symbol, out var myData);
}

public override void OnSplits(Splits splits)
{
    splits.TryGetValue(_symbol, out var split);
}

public override void OnDividends(Dividends dividends)
{
    dividends.TryGetValue(_symbol, out var dividend);
}

public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    symbolChangedEvents.TryGetValue(_symbol, out var symbolChangedEvent);
}

public override void OnDelistings(Delistings delistings)
{
    delistings.TryGetValue(_symbol, out var delisting);
}

def on_data(self, slice: Slice) -> None:
    my_data = slice.get(self._symbol)
    
def on_splits(self, splits: Splits) -> None:
    split = splits.get(self._symbol)
    
def on_dividends(self, dividends: Dividends) -> None:
    dividend = dividends.get(self._symbol)
    
def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    symbol_changed_event = symbol_changed_events.get(self._symbol])
        
def on_delistings(self, delistings: OnDelistings) -> None:
    delisting = delistings.get(self._symbol)

The OnData on_data method is the primary event handler for receiving financial data events to your algorithm. It is triggered sequentially at the point in time the data is available; in backtesting and live. For daily data this means the event is processed at midnight in backtesting or 6am the following day in live trading. In this method, all data for a given moment of time is grouped in a single event, including custom data types. This data is passed with the Slice object.

When fill-forward is enabled for your asset, the OnData event handler will be called regularly even if there was no new data. This is the default behavior.

In backtesting, if your algorithm takes a long time to process a slice, the following slice objects queue up and the next event triggers when your algorithm finishes processing the current slice. In live trading, if your algorithm takes longer to process the current slice than the time period that the slice spans, the next event triggers when your algorithm finishes processing the current slice, but the slice of the following event is the most recent slice. For example, say your algorithm consumes second resolution Crypto data but it takes your algorithm 3.5 seconds to process each slice. In backtesting, you'll get every slice. In live trading, if you deploy at 12:00:00 AM Coordinated Universal Time (UTC), you'll get the first slice at 12:00:01 AM UTC (spanning 12:00:00 AM UTC to 12:00:01 AM UTC) and you'll get the second slice at 12:00:04.5 AM UTC (roughly spanning 12:00:03 AM UTC to 12:00:04 AM UTC).

The OnSplits on_splits , OnDividends on_dividends , OnSymbolChangedEvents on_symbol_changed_events , and OnDelistings on_delistings event handlers provide data for their respective types in an isolated way. However, all of the data for these corporate actions is also available in the Slice in OnData on_data .

To perform intensive computation before the market opens, use a Scheduled Event or the Train train method.

For more information on the Slice object and OnData event, see Handling Data .

Securities Changed Event

public override void OnSecuritiesChanged(SecurityChanges changes)
{
    foreach (var security in changes.AddedSecurities)
    {
        Debug($"{Time}: Added {security.Symbol}");
    }
    foreach (var security in changes.RemovedSecurities)
    {
        Debug($"{Time}: Removed {security.Symbol}");
        
        if (security.Invested)
        {
            Liquidate(security.Symbol, "Removed from Universe");
        }
    }
}

def on_securities_changed(self, changes: SecurityChanges) -> None:
    for security in changes.added_securities::
        self.debug(f"{self.time}: Added {security.symbol}")

    for security in changes.removed_securities:
        self.debug(f"{self.time}: Removed {security.symbol}")
        
        if security.invested:
            self.liquidate(security.symbol, "Removed from Universe")

The OnSecuritiesChanged on_securities_changed event notifies the algorithm when assets are added or removed from the universe. This can be due to changes in the Universe constituents , delisting , contract expiration, or an explicit call to the RemoveSecurity remove_security method.

The event is triggered immediately when the asset is removed from the universe; however the data feed for the asset may remain active if the algorithm has open orders.

For more information, see how to use Security Changed Events .

Order Events

public override void OnOrderEvent(OrderEvent orderEvent)
{
    var order = Transactions.GetOrderById(orderEvent.OrderId);
    if (orderEvent.Status == OrderStatus.Filled)
    {
        Debug($"{Time}: {order.Type}: {orderEvent}");
    }
}

public override void OnAssignmentOrderEvent(OrderEvent assignmentEvent)
{
    Log(assignmentEvent.ToString());
}

def on_order_event(self, order_event: OrderEvent) -> None:
    order = self.transactions.get_order_by_id(order_event.order_id)
    if order_event.status == OrderStatus.FILLED:
        self.debug(f"{self.time}: {order.type}: {order_event}")

def on_assignment_order_event(self, assignment_event: OrderEvent) -> None:
    self.log(str(assignment_event))

The OnOrderEvent on_order_event method notifies the algorithm of new orders, and changes in the order status such as fill events and cancelations. For options assignment events there is a dedicated event handler OnAssignmentOrderEvent on_assignment_order_event .

In backtesting order events are triggered synchronously after the main data events. In live trading, order events are asynchronously as they occur. To avoid infinite loops, we recommend not to place orders in the OnOrderEvent.

For more information, see how to use Order Events .

Brokerage Events

public override void OnBrokerageMessage(BrokerageMessageEvent message)
{
    if (message.Type== BrokerageMessageType.Reconnect)
    {
        Log($"{Time}: {message.Type}: Message: {message.Message}");
    }
}

public override void OnBrokerageDisconnect()
{
    Log($"Brokerage disconnection detected at {Time}.");
}

public override void OnBrokerageReconnect()
{
    Log($"Brokerage reconnected at {Time}.");
}

def on_brokerage_message(self, message: BrokerageMessageEvent) -> None: 
    if message.type == BrokerageMessageType.RECONNECT:
        self.log(f"{self.time}: {message.type}: Message: {message.message}")

def on_brokerage_disconnect(self) -> None:
    self.log(f"Brokerage disconnection detected at {self.time}")

def on_brokerage_reconnect(self) -> None:
    self.log(f"Brokerage reconnected at {self.time}")

The OnBrokerageDisconnect on_brokerage_disconnect and OnBrokerageReconnect on_brokerage_reconnect event handlers pass information to the algorithm about the brokerage connection status. This can be helpful for considering when to place a trade when a brokerage API is unreliable or under maintenance. The OnBrokerageMessage on_brokerage_message event handler provides information from the brokerages, including the disconnect and reconnect messages. Message content varies with each brokerage.

Brokerage events are triggered asynchronously in live trading, and are not created in backtesting.

Margin Call Events

public override void OnMarginCall(List requests)
{
    foreach (var orderRequest in requests) {
    }
}

public override void OnMarginCallWarning()
{
    Log("Margin call warning, 5% margin remaining");
}

def on_margin_call(self, requests): -> List[SubmitOrderRequest]: 
    # Modify order requests to choose what to liquidate.
    return requests

def on_margin_call_warning(self) -> None:
    self.log("Margin call warning, 5% margin remaining")

The OnMarginCallWarning on_margin_call_warning and OnMarginCall on_margin_call event handlers provide information and control over how to reduce algorithm leverage when performance is poor.

The OnMarginCallWarning on_margin_call_warning method is called when there is less than 5% margin remaining, this gives you an opportunity to reduce leverage before an official margin call is performed by the brokerage. The OnMarginCall on_margin_call event handler is passed a list of SubmitOrderRequest objects which will be executed on exiting the method.

Margin events are called before the data events are processed.

The following demonstration demonstration processes suggested orders and modifies the qualities to liquidate more than necessary and prevent a second margin call. For more information, see how to handle Margin Calls .

Warmup Finished Event

public override void OnWarmupFinished()
{
    // Done warming up
}

def on_warmup_finished(self) -> None:
    pass # Done warming up

The OnWarmupFinished on_warmup_finished event handler is triggered after initialization and warm up is complete. This event signals that the initialization of the algorithm is complete.

For more information, see how to use Warm Up to prepare your algorithm.

End Of Algorithm Events

def on_end_of_algorithm(self) -> None:
    self.debug("Algorithm done")

public override void OnEndOfAlgorithm()
{
    Debug("Algorithm done");
}

The OnEndOfAlgorithm on_end_of_algorithm event handler is when the algorithm has finished executing as its final step. This is helpful for performing final analysis, or saving algorithm state.

Event Flow

When you deploy an algorithm, LEAN first calls the Initialize initialize method. In live mode, the engine loads your holdings and open orders from your brokerage account to add data subscriptions and populate the Securities securities , Portfolio portfolio , and Transactions transactions objects. LEAN receives the data from the subscriptions, synchronizes the data to create a timeslice , and then performs the following steps. Your algorithm can spend up to 10 minutes on each timeslice unless you call the Train train method.

1. If it's a backtest, check if there are Scheduled Events in the past that didn't fire because there was no data between the previous slice and the current slice. LEAN automatically creates a Scheduled Event to call the OnEndOfDay on_end_of_day method at the end of each day.

In live mode, Scheduled Events occur in a separate thread from the algorithm manager, so they run at the correct time.

2. Update the algorithm time.
3. Update the CurrentSlice current_slice .
4. Pass the SymbolChangedEvents to the OnSymbolChangedEvents on_symbol_changed_events method.
5. Cancel all open orders for securities that changed their ticker .
6. Add a Security object to the Securities securities collection for each new security in the universe.
7. Update the Security objects with the latest data.
8. Update the Cash objects in the CashBook with the latest data.
9. Process fill models for non-market orders.
   
10. Submit market on open orders to liquidate Equity Option contracts if the underlying Equity has a split warning .
11. Process margin calls .
    
12. If it's time to settle unsettled cash , perform settlement.
13. Call the OnSecuritiesChanged on_securities_changed method with the latest security changes.
14. Apply dividends to the portfolio.
15. For securities that have a split warning, update their portfolio holdings and adjust their open orders to account for the split.
16. Update consolidators with the latest data.
    
17. Pass custom data to the OnData on_data method.
18. Pass the Dividends to the OnDividends on_dividends method.
19. Pass the Splits to the OnSplits on_splits method.
20. Pass the Delistings to the OnDelistings on_delistings method.
21. Pass the Slice to the OnData on_data method.
22. Perform universe selection .
23. Pass the Slice to the Update update method of each Alpha model .
24. Pass the Insight objects from the Alpha model to the Portfolio Construction model .
25. Pass the PortfolioTarget objects from the Portfolio Construction model to each Risk Management model .
26. Pass the risk-adjusted PortfolioTarget objects from the Risk Management models to the Execution model .

When your algorithm stops executing, LEAN calls the OnEndOfAlgorithm on_end_of_algorithm method .

Key Concepts > Python and LEAN

Introduction

The LEAN open-source package powers the core functionality of QuantConnect. Strategies plugin to LEAN to request data, and process trades. LEAN is written in C# and accessed in python with a defined API. Most of these interactions are using native python types, with a few key exceptions. To comfortably use LEAN you should learn to recognize error messages when you hit a non-native API, and how to convert back to a native type.

Enumerable Types

When LEAN returns an enumerable, the object should be converted to a list() to be easily read by python classes. Popular API methods which return an enumerable are shown below:

Historical Data

QuantConnect also provides methods to request historical data that return a pandas dataframe, or an enumerable. If loading a large amount of data using an enumerable streams the results reducing RAM usage.

The enumerable types might look like the MemoizingEnumerable that is a raw C# type accessible in python.

You can directly enumerate this object with standard python for loops, or to convert it to a native type, wrap the object in the list() :

Underlying Plugin Architecture

Your strategy code implements the QCAlgorithm class, which can communicate with the LEAN Engine. These method calls are done at the same speed as cython, directly invoking calls at the C layer of python. Your algorithm is imported as syntax checked, interpreted python.

Key Concepts > Duck Typing

Introduction

Duck typing is popular type system in Python. The language documentation defines duck typing as follows:

A programming style which does not look at an object's type to determine if it has the right interface; instead, the method or attribute is simply called or used (“If it looks like a duck and quacks like a duck, it must be a duck.”) By emphasizing interfaces rather than specific types, well-designed code improves its flexibility by allowing polymorphic substitution.

Duck-typing avoids tests using type() or isinstance() . (Note, however, that duck-typing can be complemented with abstract base classes .) Instead, it typically employs hasattr() tests or EAFP programming.

You cannot use duck-typing to add members to regular C# types.

You can use duck-typing to add attributes to all non-primitive types in Python

class Duck { }
var duck = new Duck();
duck.quacks = "Quack!"   // Yields a compilation error

dynamic duck = new Duck();
duck.quacks = "Quack!"   // Yields a runtime error

class Duck:
    pass

duck = Duck()
duck.quacks = "Quack!"
print(duck.quacks)

LEAN allows duck-typing in the Security type.

Custom Security Properties

You can add properties attributes to the Security object. For example, you can add an exponential moving average .

dynamic equity = AddEquity("SPY");
equity.ema = EMA(equity.Symbol, 10, Resolution.Daily);

equity = self.add_equity("SPY")
equity.ema = self.ema(equity.symbol, 10, Resolution.DAILY)

This feature is helpful because you can get the Security object from the Securities securities object.

var ema = (Securities["SPY"] as dynamic).ema.Current.Value;

ema = self.securities["SPY"].ema.current.value

Other Types

You can only add properties to the Security type.

You can add properties to all types. However, these properties live in the Python space, so you can't access them without a reference. The following example demonstrates that you can add an exponential moving average to the symbol attribute of a Security object.

equity = self.add_equity("SPY")
self._symbol = equity.symbol
self._symbol.ema = self.ema(self._symbol, 10)
ema = self._symbol.ema.current.value

ema = self.securities["SPY"].symbol.ema.current.value   # 'Symbol' object has no attribute 'time'

Key Concepts > Research Guide

Introduction

We aim to teach and inspire our community to create high-performing algorithmic trading strategies. We measure our success by the profits community members create through their live trading. As such, we try to build the best quantitative research techniques possible into the product to encourage a robust research process.

Hypothesis-Driven Research

We recommend you develop an algorithmic trading strategy based on a central hypothesis. You should develop an algorithm hypothesis at the start of your research and spend the remaining time exploring how to test your theory. If you find yourself deviating from your core theory or introducing code that isn't based around that hypothesis, you should stop and go back to thesis development.

Wang et al. (2014) illustrate the danger of creating your hypothesis based on test results. In their research, they examined the earnings yield factor in the technology sector over time. During 1998-1999, before the tech bubble burst, the factor was unprofitable. If you saw the results and then decided to bet against the factor during 2000-2002, you would have lost a lot of money because the factor performed extremely well during that time.

Hypothesis development is somewhat of an art and requires creativity and great observation skills. It is one of the most powerful skills a quant can learn. We recommend that an algorithm hypothesis follow the pattern of cause and effect. Your aim should be to express your strategy in the following sentence:

A change in {cause} leads to an {effect}.

To search for inspiration, consider causes from your own experience, intuition, or the media. Generally, causes of financial market movements fall into the following categories:

• Human psychology
• Real-world events/fundamentals
• Invisible financial actions

Consider the following examples:

There are millions of potential alpha strategies to explore, each of them a candidate for an algorithm. Once you have chosen a strategy, we recommend exploring it for no more than 8-32 hours, depending on your coding ability.

Data Mining Driven Research

An alternative view is to follow any statistical anomaly without explaining it. In this case, you can use statistical techniques to identify the discontinuities and eliminate them when their edge is gone. Apparently, Renaissance Technologies has data mining models like this.

Overfitting

Overfitting occurs when you fine-tune the parameters of an algorithm to fit the detail and noise of backtesting data to the extent that it negatively impacts the performance of the algorithm on new data. The problem is that the parameters don't necessarily apply to new data and thus negatively impact the algorithm's ability to generalize and trade well in all market conditions. The following table shows ways that overfitting can manifest itself:

An algorithm that is dynamic and generalizes to new data is more valuable to funds and individual investors. It is more likely to survive across different market conditions and apply to new asset classes and markets.

If you have a collection of factors, you can backtest over a period of time to find the best-performing factors for the time period. If you then narrow the collection of factors to just the best-performing ones and backtest over the same period, the backtest will show great results. However, if you take the same best-performing factors and backtest them on an out-of-sample dataset, the performance will almost always underperform the in-sample period. To avoid issues with overfitting, follow these guidelines:

• Use walk-forward optimization to train your models on historical data and test them on future data.
• Test your strategy with live paper trading.
• Test your model on different asset classes and markets.

Look-ahead Bias

Look-ahead bias occurs when you use information from the future to inform decisions in the present. An example of look-ahead bias is using financial statement data to make trading decisions at the end of the reporting period instead of when the financial statement data was released. Another example is using updated financial statement data before the updated figures were actually available. Wang et al. (2014) show that using the date of when the period ends instead of when the data is actually available can increase the performance of the earnings yield factor by 60%.

Another culprit of look-ahead bias is adjusted price data. Splits and reverse splits can improve liquidity or attract certain investors, causing the performance of the stock to be different than without the split or reverse split. Wang et al (2014) build a portfolio using the 25 lowest priced stocks in the S&P index based on adjusted and non-adjusted prices. The portfolio based on adjusted prices greatly outperformed the one with raw prices in terms of return and Sharpe ratio . In this case, if you were to analyze the low price factor with adjusted prices, it would lead you to believe the factor is very informative, but it would not perform well out-of-sample with raw data.

Look-ahead bias can also occur if you set the universe to assets that have performed well during the backtest period or initialize indicators with values that have performed well during the backtest period. To avoid issues with look-ahead bias, trade a dynamic universe of assets and use point-in-time data. If point-in-time data is not available for the dataset you use, apply a reporting lag. Since the backtesting environment is event-driven and you can't pass the time frontier, it naturally helps to reduce the risk of look-ahead bias.

Survivorship Bias

Survivorship bias occurs when you test a strategy using only the securities that have survived to the end of the testing period and omit securities that have been delisted. If you use the current constituents of an index and backtest over the past, you'll most likely outperform the index because many of the underperformers have dropped out of the index over time and outperformers have been added to the index. In this case, the current constituent universe would consist of only outperformers. This technique is a form of look-ahead bias because if you were trading the strategy in real-time throughout the backtest period, you would not know the current index constituents until today.

If you analyze a dataset that has survivorship bias, you can discover results that are opposite of the true results. For example, Wang et al. (2014) analyze the low volatility factor using two universes. The first universe was the current S&P 500 constituents and the second universe was the point-in-time constituents. When they used the point-in-time constituents, the low volatility quintile outperformed the high volatility quintile. However, when they used the current constituents, the high volatility quintile significantly outperformed the low volatility quintile.

To avoid issues with survivorship bias, trade a dynamic universe of assets and use the datasets in the Dataset Market . We thoroughly vet the datasets we add to the market to ensure they're free of survivorship bias.

Outliers

Outliers in a dataset can have large impacts on how models train. In some cases, you may leave outliers in a dataset because they can contain useful information. In other cases, you may want to transform the data to handle the outlier data points. There are several common methods to handle outliers.

Winsorization Method

The winsorization method removes outliers at the $x$% of the extremes. For example, if you winsorize at 1%, it removes the 1% of data points with the lowest value and the 1% of data points with the highest value. This threshold percentage is subjective, so it can result in overfitting.

IQR Method

The interquartile range method removes data points that fall outside of the interval \([Q_1 - k (Q_3 - Q_1),\ Q_3 + k (Q_3 - Q_1)]\) for some constant \(k\ge 0\). This method can exclude up to 25% of observations on each side of the extremes. The interquartile range method doesn't work if the data is skewed or non-normal. Therefore, the disadvantage to this method is you need to review the factor distribution properties. If you need to, you can normalize the data with z-scores.

Factor Ranking Method

The factor ranking method ranks the data values instead of taking their raw values. With this method, you don't need to remove any outlier data points. This method transforms the data into a uniform distribution. After converting the data to a uniform distribution, Wang et al. (2014) perform an inverse normal transformation to make the factor values normally distributed. Wang et al. found this ranking technique outperforms the z-score transformation, suggesting that the distance between factor scores doesn't add useful information.

Short Availability

To open a short position, you need to borrow shares from an investor or brokerage that owns them. Wang et al. (2014) show that some factors have a larger edge for long positions and some have a larger edge for short positions. Their research found that the factors that perform better on the short side usually target more securities that are on hard-to-borrow lists than factors that perform better on the long side. Their research also shows that a large part of the returns from these short-biased factors come from securities that are on hard-to-borrow lists. Therefore, if you don't account for short availability, your backtest results can be unrealistic and not reproducible in live trading.

To avoid issues with short availability, add a shortable provider to your algorithm. The shortable provider only lets you open a short trade if there are actually shares available to borrow. LEAN doesn't currently model the fees associated with short positions, but we have an open GitHub Issue to add the functionality. Subscribe to GitHub Issue #4563 to track the feature progress.

Key Concepts > Globals and Statics

Introduction

It is often convenient to access the QCAlgorithm API in classes outside of the QCAlgorithm class. To achieve this, pass an instance reference or access a global static variable. Whenever possible, we recommend using an instance reference to keep your global namespace clean.

API Access by Algorithm Instance

You can access the QCAlgorithm API by passing the self this object into a constructor of your target class. The class constructor receives it as a variable that you can use to initialize your algorithm as you need. The following algorithm demonstrates this process:

public class CustomPartialFillModelAlgorithm : QCAlgorithm
{
    private Symbol _spy;
    private SecurityHolding _holdings;
     
    public override void Initialize()
    {
        SetStartDate(2019, 1, 1);
        SetEndDate(2019, 3, 1);

        var equity = AddEquity("SPY", Resolution.Hour);
        _spy = equity.Symbol;
        _holdings = equity.Holdings;

        // Set the fill model with the instance of the algorithm
        equity.SetFillModel(new CustomPartialFillModel(this));
    }
     
    public override void OnData(Slice data)
    {
        var openOrders = Transactions.GetOpenOrders(_spy);
        if (openOrders.Count != 0) return;

        if (Time.Day > 10 && _holdings.Quantity <= 0)
        {
            MarketOrder(_spy, 105, true);
        }
        else if (Time.Day > 20 && _holdings.Quantity >= 0)
        {
            MarketOrder(_spy, -100, true);
        }
    }

    internal class CustomPartialFillModel : FillModel
    {
        private readonly QCAlgorithm _algorithm;
        private readonly Dictionary<int, decimal> _absoluteRemainingByOrderId = new();
     
        public CustomPartialFillModel(QCAlgorithm algorithm)
            : base()
        {
            _algorithm = algorithm;
        }
     
        public override OrderEvent MarketFill(Security asset, MarketOrder order)
        {
            if (!_absoluteRemainingByOrderId.TryGetValue(order.Id, out var absoluteRemaining))
            {
              absoluteRemaining = order.AbsoluteQuantity;
            }
     
            var fill = base.MarketFill(asset, order);
     
            fill.FillQuantity = Math.Sign(order.Quantity) * 10m;
            if (Math.Min(Math.Abs(fill.FillQuantity), absoluteRemaining) == absoluteRemaining)
            {
                fill.FillQuantity = Math.Sign(order.Quantity) * absoluteRemaining;
                fill.Status = OrderStatus.Filled;
                _absoluteRemainingByOrderId.Remove(order.Id);
            }
            else
            {
                fill.Status = OrderStatus.PartiallyFilled;
                _absoluteRemainingByOrderId[order.Id] = absoluteRemaining - Math.Abs(fill.FillQuantity);
                 var price = fill.FillPrice;

                // Use the instance of the algorithm to log the information
                _algorithm.Debug($"{_algorithm.Time} - Partial Fill - Remaining {_absoluteRemainingByOrderId[order.Id]} Price - {price}");
            }
            return fill;
        }
    }
}

class CustomPartialFillModelAlgorithm(QCAlgorithm):      
    def initialize(self):
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2019, 3, 1)

        equity = self.add_equity("SPY", Resolution.HOUR)
        self._spy = equity.symbol
        self._holdings = equity.holdings

        # Set the fill model with the instance of the algorithm
        equity.set_fill_model(CustomPartialFillModel(self))

    def on_data(self, data):
        open_orders = self.transactions.get_open_orders(self.spy)
        if len(open_orders) != 0: return

        if self.time.day > 10 and self._holdings.quantity <= 0:
            self.market_order(self._spy, 105, True)

        elif self.time.day > 20 and self._holdings.quantity >= 0:
            self.market_order(self._spy, -100, True)
      
class CustomPartialFillModel(FillModel):
    def __init__(self, algorithm):
        self._algorithm = algorithm
        self._absolute_remaining_by_order_id = {}

    def market_fill(self, asset, order):
        absolute_remaining = self._absolute_remaining_by_order_id.get(order.id, order.absolute_quantity)
        fill = super().market_fill(asset, order)
        fill.fill_quantity = np.sign(order.quantity) * 10
        if (min(abs(fill.fill_quantity), absolute_remaining) == absolute_remaining):
            fill.fill_quantity = np.sign(order.quantity) * absolute_remaining
            fill.status = OrderStatus.FILLED
            self._absolute_remaining_by_order_id.pop(order.id, None)
        else:
            fill.status = OrderStatus.PARTIALLY_FILLED
            self._absolute_remaining_by_order_id[order.id] = absolute_remaining - abs(fill.fill_quantity)
            price = fill.fill_price
            # Use the instance of the algorithm to log the information
            self._algorithm.debug(f"{self._algorithm.time} - Partial Fill - Remaining {self._absolute_remaining_by_order_id[order.id]} Price - {price}")
      
        return fill

API Access by Global Static Variable

Occasionally, passing the QCAlgorithm object to your class constructor is impossible, so you need to use global static variables to access the API for debugging and initialization purposes. The most common case is custom data implementations , where the LEAN Engine is creating the objects and you're unable to specify a custom constructor.

To create a global static variable, assign the reference to the global variable in the algorithm's Initialize initialize method. This assignment sets the active instance of the variable to the global static. Then, in your custom class, you can access the QCAlgorithm API through the global. The following algorithm demonstrates this process:

public class MyCustomDataTypeAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        MyCustomDataType.ALGORITHM = this;
        var symbol = AddData<MyCustomDataType>("<name>", Resolution.Daily).Symbol;
    }
}

public class MyCustomDataType : BaseData
{
    public static QCAlgorithm ALGORITHM;

    public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
    {
        if (!char.IsDigit(line.Trim()[0]))
        {
            // Display the line with the header
            ALGORITHM.Debug($"HEADER: {line}");
            return null;
        }
        var data = line.Split(',');
        return new MyCustomDataType()
        {
            Time = DateTime.ParseExact(data[0], "yyyyMMdd", CultureInfo.InvariantCulture),
            EndTime = Time.AddDays(1),
            Symbol = config.Symbol,
            Value = data[1].IfNotNullOrEmpty(
                s => decimal.Parse(s, NumberStyles.Any, CultureInfo.InvariantCulture)),
        };
    }
}

class MyAlgorithmInstance(QCAlgorithm):

    def initialize(self):
        self.set_cash(100000)
        self.set_start_date(1998, 1, 1)
        self.set_end_date(2014, 6, 1)
            
        # Assign self to Static Cape Variable.
        Cape.algorithm = self
        self.add_data(Cape, "CAPE")
    
    def on_data(self, data):
        self.plot("CAPE", "Value", data["CAPE"].value)
    
class Cape(PythonData):  
    def get_source(self, config, date, isLiveMode): 
        Cape.algorithm.debug("Test Static: GetSource")
        return SubscriptionDataSource("https://www.dropbox.com/scl/fi/mqbnfb7ll88nne7b8ymy7/CAPE.csv?rlkey=mnu0ax1d8lcj3gzkdw79z0pm8&dl=1", SubscriptionTransportMedium.REMOTE_FILE)
        
    def reader(self, config, line, date, isLiveMode):
        if not (line.strip() and line[0].isdigit()): return None 
        index = Cape()
        try: 
            data = line.split(',') 
            index.symbol = config.symbol
            index.time = datetime.strptime(data[0], "%Y-%m") 
            index.value = float(data[10])
        except ValueError: 
            Cape.algorithm.debug("Test Static 2: ValueError")
            return None 
        return index

Key Concepts > Libraries

Introduction

Libraries (or packages) are third-party software that you can use in your projects. You can use many of the available open-source libraries to complement the classes and methods that you create. Libraries reduce your development time because it's faster to use a pre-built, open-source library than to write the functionality. Libraries can be used in backtesting, research, and live trading. The environments support various libraries for machine learning, plotting, and data processing. As members often request new libraries, we frequently add new libraries to the underlying docker image that runs the Lean engine.

This feature is primarily for Python algorithms as not all Python libraries are compatible with each other. We've bundled together different sets of libraries into distinct environments. To use the libraries of an environment, set the environment in your project and add the relevant using import statement of a library at the top of your file.

Default Environment Libraries

The default environment supports the following libraries:

absl-py                                 2.1.0
accelerate                              0.30.1
adagio                                  0.2.4
aesara                                  2.9.3
aiohttp                                 3.9.5
aiosignal                               1.3.1
aiosqlite                               0.20.0
alembic                                 1.13.1
alibi-detect                            0.12.0
alphalens-reloaded                      0.4.3
altair                                  5.2.0
aniso8601                               9.0.1
annotated-types                         0.7.0
antlr4-python3-runtime                  4.9.3
anyio                                   4.4.0
appdirs                                 1.4.4
apricot-select                          0.6.1
arch                                    6.3.0
argon2-cffi                             23.1.0
argon2-cffi-bindings                    21.2.0
arrow                                   1.3.0
arviz                                   0.18.0
astropy                                 6.0.0
astropy-iers-data                       0.2024.6.3.0.31.14
asttokens                               2.4.1
astunparse                              1.6.3
async-lru                               2.0.4
attrs                                   23.2.0
Authlib                                 1.3.0
autograd                                1.6.2
autograd-gamma                          0.5.0
autokeras                               2.0.0
autoray                                 0.6.12
ax-platform                             0.3.7
Babel                                   2.15.0
bayesian-optimization                   1.4.3
beautifulsoup4                          4.12.3
bleach                                  6.1.0
blinker                                 1.8.2
blis                                    0.7.11
blosc2                                  2.6.2
bokeh                                   3.3.4
botorch                                 0.10.0
Bottleneck                              1.3.8
cachetools                              5.3.3
captum                                  0.7.0
catalogue                               2.0.10
catboost                                1.2.3
category-encoders                       2.6.3
causal-conv1d                           1.2.0.post2
chardet                                 5.2.0
check-shapes                            1.1.1
clarabel                                0.9.0
click                                   8.1.7
clikit                                  0.6.2
cloudpathlib                            0.16.0
cloudpickle                             3.0.0
cmdstanpy                               1.2.1
colorama                                0.4.6
colorcet                                3.1.0
colorlog                                6.8.2
colorlover                              0.3.0
colour                                  0.1.5
comm                                    0.2.2
confection                              0.1.5
cons                                    0.4.6
contourpy                               1.2.0
control                                 0.9.4
copulae                                 0.7.9
copulas                                 0.10.1
coreforecast                            0.0.9
cramjam                                 2.8.3
crashtest                               0.3.1
creme                                   0.6.1
cufflinks                               0.17.3
cvxopt                                  1.3.2
cvxpy                                   1.4.2
cycler                                  0.12.1
cymem                                   2.0.8
Cython                                  3.0.10
darts                                   0.28.0
dash                                    2.17.0
dash-core-components                    2.0.0
dash-cytoscape                          1.0.1
dash-html-components                    2.0.0
dash-table                              5.0.0
dask                                    2024.3.1
dask-expr                               1.0.5
dataclasses-json                        0.6.6
datasets                                2.17.1
deap                                    1.4.1
debugpy                                 1.6.7.post1
decorator                               5.1.1
deepmerge                               1.1.1
defusedxml                              0.7.1
Deprecated                              1.2.14
deprecation                             2.1.0
dgl                                     2.1.0
dill                                    0.3.8
dimod                                   0.12.14
dirtyjson                               1.0.8
diskcache                               5.6.3
distributed                             2024.3.1
dm-tree                                 0.1.8
docker                                  7.1.0
docutils                                0.20.1
DoubleML                                0.7.1
dropstackframe                          0.1.0
dtreeviz                                2.2.2
dtw-python                              1.3.1
dwave-cloud-client                      0.11.3
dwave-drivers                           0.4.4
dwave-greedy                            0.3.0
dwave-hybrid                            0.6.11
dwave-inspector                         0.4.4
dwave-inspectorapp                      0.3.1
dwave-neal                              0.6.0
dwave-networkx                          0.8.14
dwave-ocean-sdk                         6.9.0
dwave-preprocessing                     0.6.5
dwave-samplers                          1.2.0
dwave-system                            1.23.0
dwave-tabu                              0.5.0
dwavebinarycsp                          0.3.0
ecos                                    2.0.13
einops                                  0.7.0
EMD-signal                              1.6.0
empyrical-reloaded                      0.5.10
en-core-web-md                          3.7.1
en-core-web-sm                          3.7.1
entrypoints                             0.4
et-xmlfile                              1.1.0
etuples                                 0.3.9
exchange_calendars                      4.5.4
executing                               2.0.1
faiss-cpu                               1.8.0
Farama-Notifications                    0.0.4
fastai                                  2.7.14
fastai2                                 0.0.30
fastcore                                1.5.43
fastdownload                            0.0.7
fasteners                               0.19
fastjsonschema                          2.19.1
fastparquet                             2024.2.0
fastprogress                            1.0.3
fasttext                                0.9.2
feature-engine                          1.6.2
featuretools                            1.30.0
filelock                                3.14.0
findiff                                 0.10.0
FixedEffectModel                        0.0.5
FlagEmbedding                           1.2.10
FLAML                                   2.1.2
Flask                                   3.0.3
flatbuffers                             24.3.25
fonttools                               4.53.0
formulaic                               1.0.1
fqdn                                    1.5.1
frozendict                              2.4.4
frozenlist                              1.4.1
fs                                      2.4.16
fsspec                                  2023.10.0
fugue                                   0.9.0
functime                                0.9.5
future                                  1.0.0
fuzzy-c-means                           1.7.2
gast                                    0.5.4
gensim                                  4.3.2
gevent                                  24.2.1
gitdb                                   4.0.11
GitPython                               3.1.43
gluonts                                 0.14.4
google-pasta                            0.2.0
gpflow                                  2.9.1
gplearn                                 0.4.2
gpytorch                                1.11
graphene                                3.3
graphql-core                            3.2.3
graphql-relay                           3.2.0
graphviz                                0.20.1
greenlet                                3.0.3
grpcio                                  1.64.1
gunicorn                                21.2.0
gym                                     0.26.2
gym-notices                             0.0.8
gymnasium                               0.28.1
h11                                     0.14.0
h2o                                     3.46.0.1
h5netcdf                                1.3.0
h5py                                    3.11.0
hmmlearn                                0.3.2
holidays                                0.50
holoviews                               1.18.3
homebase                                1.0.1
hopcroftkarp                            1.2.5
html5lib                                1.1
httpcore                                1.0.5
httpstan                                4.12.0
httpx                                   0.27.0
huggingface-hub                         0.23.2
hurst                                   0.0.5
hvplot                                  0.9.2
hydra-core                              1.3.0
hyperopt                                0.2.7
ibm-cloud-sdk-core                      3.20.1
ibm-platform-services                   0.53.7
iisignature                             0.24
ijson                                   3.2.3
imageio                                 2.34.1
imbalanced-learn                        0.12.0
immutabledict                           4.2.0
importlib_metadata                      7.1.0
importlib_resources                     6.4.0
iniconfig                               2.0.0
injector                                0.21.0
interface-meta                          1.3.0
interpret                               0.5.1
interpret-core                          0.5.1
ipykernel                               6.29.4
ipython                                 8.25.0
ipywidgets                              8.1.2
isoduration                             20.11.0
itsdangerous                            2.2.0
jax                                     0.4.25
jax-jumpy                               1.0.0
jaxlib                                  0.4.25
jaxtyping                               0.2.29
jedi                                    0.19.1
Jinja2                                  3.1.4
joblib                                  1.3.2
json5                                   0.9.25
jsonpatch                               1.33
jsonpath-ng                             1.6.1
jsonpointer                             2.1
jsonschema                              4.21.1
jsonschema-specifications               2023.12.1
jupyter                                 1.0.0
jupyter-console                         6.6.3
jupyter-events                          0.10.0
jupyter-lsp                             2.2.5
jupyter-resource-usage                  1.0.2
jupyter_ai                              2.12.0
jupyter_ai_magics                       2.16.0
jupyter_bokeh                           4.0.0
jupyter_client                          8.6.2
jupyter_core                            5.7.2
jupyter_server                          2.14.1
jupyter_server_terminals                0.5.3
jupyterlab                              4.1.5
jupyterlab_pygments                     0.3.0
jupyterlab_server                       2.27.2
jupyterlab_widgets                      3.0.11
kagglehub                               0.2.5
kaleido                                 0.2.1
keras                                   3.3.3
keras-core                              0.1.7
keras-nlp                               0.12.1
keras-rl                                0.4.2
keras-tcn                               3.5.0
keras-tuner                             1.4.7
kiwisolver                              1.4.5
kmapper                                 2.0.1
korean-lunar-calendar                   0.3.1
kt-legacy                               1.0.5
langchain                               0.1.12
langchain-community                     0.0.38
langchain-core                          0.1.52
langchain-text-splitters                0.0.2
langcodes                               3.4.0
langsmith                               0.1.67
language_data                           1.2.0
lark                                    1.1.9
lazy_loader                             0.4
lazypredict-nightly                     0.3.0
libclang                                18.1.1
lifelines                               0.28.0
lightgbm                                4.3.0
lightning                               2.2.5
lightning-utilities                     0.11.2
lime                                    0.2.0.1
line-profiler                           4.1.2
linear-operator                         0.5.1
linkify-it-py                           2.0.3
livelossplot                            0.5.5
llama-index                             0.10.19
llama-index-agent-openai                0.1.7
llama-index-cli                         0.1.12
llama-index-core                        0.10.43
llama-index-embeddings-openai           0.1.10
llama-index-indices-managed-llama-cloud 0.1.6
llama-index-legacy                      0.9.48
llama-index-llms-openai                 0.1.22
llama-index-multi-modal-llms-openai     0.1.6
llama-index-program-openai              0.1.6
llama-index-question-gen-openai         0.1.3
llama-index-readers-file                0.1.23
llama-index-readers-llama-parse         0.1.4
llama-parse                             0.4.4
llamaindex-py-client                    0.1.19
llvmlite                                0.42.0
locket                                  1.0.0
logical-unification                     0.4.6
lxml                                    5.1.0
lz4                                     4.3.3
Mako                                    1.3.5
mamba-ssm                               1.2.0.post1
MAPIE                                   0.8.3
marisa-trie                             1.1.1
Markdown                                3.6
markdown-it-py                          3.0.0
MarkupSafe                              2.1.5
marshmallow                             3.21.2
matplotlib                              3.7.5
matplotlib-inline                       0.1.7
mdit-py-plugins                         0.4.1
mdurl                                   0.1.2
mgarch                                  0.3.0
miniKanren                              1.0.3
minorminer                              0.2.13
mistune                                 3.0.2
ml-dtypes                               0.3.2
mlflow                                  2.11.1
mlforecast                              0.12.0
mljar-supervised                        1.1.6
mlxtend                                 0.23.1
mmh3                                    2.5.1
modin                                   0.26.1
mplfinance                              0.12.10b0
mpmath                                  1.3.0
msgpack                                 1.0.8
multidict                               6.0.5
multipledispatch                        1.0.0
multiprocess                            0.70.16
multitasking                            0.0.11
murmurhash                              1.0.10
mypy-extensions                         1.0.0
namex                                   0.0.8
nbclient                                0.10.0
nbconvert                               7.16.4
nbformat                                5.10.4
ndindex                                 1.8
nest-asyncio                            1.6.0
networkx                                3.3
neural-tangents                         0.6.5
neuralprophet                           0.8.0
nfoursid                                1.0.1
ngboost                                 0.5.1
ninja                                   1.11.1.1
nltk                                    3.8.1
nolds                                   0.5.2
nose                                    1.3.7
notebook                                7.1.3
notebook_shim                           0.2.4
numba                                   0.59.0
numerapi                                2.18.0
numexpr                                 2.10.0
numpy                                   1.26.4
nvidia-cublas-cu12                      12.1.3.1
nvidia-cuda-cupti-cu12                  12.1.105
nvidia-cuda-nvrtc-cu12                  12.1.105
nvidia-cuda-runtime-cu12                12.1.105
nvidia-cudnn-cu12                       8.9.2.26
nvidia-cufft-cu12                       11.0.2.54
nvidia-curand-cu12                      10.3.2.106
nvidia-cusolver-cu12                    11.4.5.107
nvidia-cusparse-cu12                    12.1.0.106
nvidia-nccl-cu12                        2.19.3
nvidia-nvjitlink-cu12                   12.5.40
nvidia-nvtx-cu12                        12.1.105
oauthlib                                3.2.2
omegaconf                               2.3.0
openai                                  1.30.4
opencv-contrib-python-headless          4.9.0.80
opencv-python                           4.10.0.82
openpyxl                                3.1.2
opt-einsum                              3.3.0
optree                                  0.11.0
optuna                                  3.5.0
orjson                                  3.10.3
ortools                                 9.9.3963
osqp                                    0.6.7
overrides                               7.7.0
packaging                               23.2
pandas                                  2.1.4
pandas-flavor                           0.6.0
pandas-ta                               0.3.14b0
pandas_market_calendars                 4.4.0
pandocfilters                           1.5.1
panel                                   1.3.8
param                                   2.1.0
parso                                   0.8.4
partd                                   1.4.2
pastel                                  0.2.1
pathos                                  0.3.2
patsy                                   0.5.6
pbr                                     6.0.0
peewee                                  3.17.3
peft                                    0.11.1
penaltymodel                            1.1.0
PennyLane                               0.35.1
PennyLane-qiskit                        0.35.1
PennyLane_Lightning                     0.35.1
persim                                  0.3.5
pexpect                                 4.9.0
pgmpy                                   0.1.25
pillow                                  10.3.0
pingouin                                0.5.4
plotly                                  5.20.0
plotly-resampler                        0.10.0
plucky                                  0.4.3
pluggy                                  1.5.0
ply                                     3.11
pmdarima                                2.0.4
polars                                  0.20.15
pomegranate                             1.0.4
POT                                     0.9.3
pox                                     0.3.4
ppft                                    1.7.6.8
pprofile                                2.1.0
preshed                                 3.0.9
prometheus_client                       0.20.0
prompt_toolkit                          3.0.45
prophet                                 1.1.5
protobuf                                4.25.3
psutil                                  5.9.8
ptvsd                                   4.3.2
ptyprocess                              0.7.0
PuLP                                    2.8.0
pure-eval                               0.2.2
py-cpuinfo                              9.0.0
py-heat                                 0.0.6
py-heat-magic                           0.0.2
py-lets-be-rational                     1.0.1
py-vollib                               1.0.1
py4j                                    0.10.9.7
pyaml                                   24.4.0
pyarrow                                 15.0.1
pyarrow-hotfix                          0.6
pybind11                                2.12.0
pycaret                                 3.3.2
pydantic                                2.7.3
pydantic_core                           2.18.4
pydevd-pycharm                          231.9225.15
pydmd                                   1.0.0
pyerfa                                  2.0.1.4
pyfolio-reloaded                        0.9.5
Pygments                                2.18.0
PyJWT                                   2.8.0
pykalman                                0.9.7
pylev                                   1.4.0
pyluach                                 2.2.0
pymannkendall                           1.4.3
pymc                                    5.10.4
pymdptoolbox                            4.0b3
pynndescent                             0.5.12
pyod                                    2.0.0
Pyomo                                   6.7.1
pyparsing                               3.1.2
pypdf                                   4.2.0
pyportfolioopt                          1.5.5
pyre-extensions                         0.0.30
pyro-api                                0.1.2
pyro-ppl                                1.9.0
pysimdjson                              5.0.2
pyspnego                                0.10.2
pystan                                  3.9.0
pytensor                                2.18.6
pytest                                  8.2.1
python-dateutil                         2.9.0.post0
python-dotenv                           1.0.0
python-json-logger                      2.0.7
python-statemachine                     2.1.2
pytorch-ignite                          0.4.13
pytorch-lightning                       1.9.5
pytorch-tabnet                          4.1.0
pytz                                    2024.1
pyvinecopulib                           0.6.5
pyviz_comms                             3.0.2
PyWavelets                              1.5.0
PyYAML                                  6.0.1
pyzmq                                   26.0.3
qdldl                                   0.1.7.post2
qiskit                                  1.0.2
qiskit-aer                              0.14.2
qiskit-ibm-provider                     0.11.0
qiskit-ibm-runtime                      0.20.0
qtconsole                               5.5.2
QtPy                                    2.4.1
quadprog                                0.1.12
quantecon                               0.7.2
QuantLib                                1.33
QuantStats                              0.0.62
querystring-parser                      1.2.4
rauth                                   0.7.3
ray                                     2.9.3
Rbeast                                  0.1.19
rectangle-packer                        2.0.2
referencing                             0.35.1
regex                                   2024.5.15
requests-ntlm                           1.2.0
requests-oauthlib                       1.3.1
retrying                                1.3.4
rfc3339-validator                       0.1.4
rfc3986-validator                       0.1.1
rich                                    13.7.1
ripser                                  0.6.8
Riskfolio-Lib                           6.0.0
riskparityportfolio                     0.5.1
river                                   0.21.0
rpds-py                                 0.18.1
ruptures                                1.1.9
rustworkx                               0.14.2
safetensors                             0.4.3
SALib                                   1.5.0
schemdraw                               0.15
scikeras                                0.13.0
scikit-base                             0.7.8
scikit-image                            0.22.0
scikit-learn                            1.4.2
scikit-learn-extra                      0.3.0
scikit-optimize                         0.10.0
scikit-plot                             0.3.7
scikit-tda                              1.0.0
scipy                                   1.11.4
scs                                     3.2.4.post2
sdeint                                  0.3.0
seaborn                                 0.13.2
semantic-version                        2.10.0
Send2Trash                              1.8.3
sentence-transformers                   3.0.0
setuptools-scm                          8.1.0
shap                                    0.45.0
Shimmy                                  1.3.0
simplejson                              3.19.2
simpy                                   4.1.1
six                                     1.16.0
sklearn-json                            0.1.0
sktime                                  0.26.0
slicer                                  0.0.7
smart-open                              6.4.0
smmap                                   5.0.1
sniffio                                 1.3.1
sortedcontainers                        2.4.0
soupsieve                               2.5
spacy                                   3.7.4
spacy-legacy                            3.0.12
spacy-loggers                           1.0.5
SQLAlchemy                              2.0.30
sqlparse                                0.5.0
srsly                                   2.4.8
stable_baselines3                       2.3.2
stack-data                              0.6.3
stanio                                  0.3.0
statsforecast                           1.7.5
statsmodels                             0.14.1
stevedore                               5.2.0
stochastic                              0.6.0
stockstats                              0.6.2
stopit                                  1.1.2
striprtf                                0.0.26
stumpy                                  1.12.0
symengine                               0.11.0
sympy                                   1.12.1
ta                                      0.11.0
TA-Lib                                  0.4.28
tables                                  3.9.2
tabulate                                0.8.10
tadasets                                0.2.1
tbats                                   1.1.3
tblib                                   3.0.0
tenacity                                8.3.0
tensorboard                             2.16.2
tensorboard-data-server                 0.7.2
tensorboardX                            2.6.2.2
tensorflow                              2.16.1
tensorflow-addons                       0.23.0
tensorflow-io-gcs-filesystem            0.37.0
tensorflow-probability                  0.24.0
tensorflow-text                         2.16.1
tensorflow_decision_forests             1.9.0
tensorly                                0.8.1
tensorrt                                8.6.1.post1
tensorrt-bindings                       8.6.1
tensorrt-libs                           8.6.1
tensortrade                             1.0.3
termcolor                               2.4.0
terminado                               0.18.1
tf2jax                                  0.3.6
tf_keras                                2.16.0
thinc                                   8.2.3
threadpoolctl                           3.5.0
thundergbm                              0.3.17
tifffile                                2024.5.22
tiktoken                                0.7.0
tinycss2                                1.3.0
tokenizers                              0.19.1
toml                                    0.10.2
toolz                                   0.12.1
torch                                   2.2.1
torch-cluster                           1.6.3
torch-scatter                           2.1.2
torch-sparse                            0.6.18
torch-spline-conv                       1.2.2
torch_geometric                         2.5.1
torchdata                               0.7.1
torchmetrics                            1.4.0.post0
torchvision                             0.17.1
tornado                                 6.4
TPOT                                    0.12.2
tqdm                                    4.66.4
traitlets                               5.14.3
transformers                            4.40.2
triad                                   0.9.6
triton                                  2.2.0
tsdownsample                            0.1.3
tsfresh                                 0.20.2
tslearn                                 0.6.3
tweepy                                  4.14.0
typeguard                               2.13.3
typer                                   0.9.4
typer-config                            1.4.0
types-python-dateutil                   2.9.0.20240316
typing-inspect                          0.9.0
typing_extensions                       4.12.1
tzdata                                  2024.1
uc-micro-py                             1.0.3
umap-learn                              0.5.5
update-checker                          0.18.0
uri-template                            1.3.0
utilsforecast                           0.1.10
wasabi                                  1.1.3
wcwidth                                 0.2.13
weasel                                  0.3.4
webargs                                 8.4.0
webcolors                               1.13
webencodings                            0.5.1
websocket-client                        1.8.0
websockets                              12.0
Werkzeug                                3.0.1
widgetsnbextension                      4.0.11
window_ops                              0.0.15
woodwork                                0.31.0
wordcloud                               1.9.3
wrapt                                   1.16.0
wurlitzer                               3.1.0
x-transformers                          1.30.4
xarray                                  2024.2.0
xarray-einstats                         0.7.0
xgboost                                 2.0.3
xlrd                                    2.0.1
XlsxWriter                              3.2.0
xxhash                                  3.4.1
xyzservices                             2024.4.0
yarl                                    1.9.4
yellowbrick                             1.5
yfinance                                0.2.40
zict                                    3.0.0
zipp                                    3.19.1
zope.event                              5.0
zope.interface                          6.4.post2

Accord                               3.6.0
Accord.Fuzzy                         3.6.0
Accord.MachineLearning               3.6.0
Accord.Math                          3.6.0
Accord.Statistics                    3.6.0
CloneExtensions                      1.3.0
Common.Logging                       3.4.1
Common.Logging.Core                  3.4.1
CsvHelper                            19.0.0
Deedle                               2.1.0
DotNetZip                            1.16.0
DynamicInterop                       0.9.1
fasterflect                          3.0.0
MathNet.Numerics                     5.0.0
McMaster.Extensions.CommandLineUtils 2.6.0
Microsoft.IO.RecyclableMemoryStream  2.3.2
Microsoft.NET.Test.Sdk               16.9.4
Microsoft.TestPlatform.ObjectModel   16.9.4
Moq                                  4.16.1
NetMQ                                4.0.1.6
Newtonsoft.Json                      13.0.2
NodaTime                             3.0.5
NUnit                                3.13.3
NUnit3TestAdapter                    4.2.1
Plotly.NET                           3.0.1
Plotly.NET.Interactive               3.0.2
protobuf-net                         3.1.3
QLNet                                1.13.0
QuantConnect.pythonnet               2.0.38
RestSharp                            106.12.0
SharpZipLib                          1.3.3
System.ComponentModel.Composition    6.0.0

Autokeras Environment Libraries

This environment is only available for Python projects.

The Autokeras environment provides a backwards compatability environment for compatibility with Keras < 3 , Tensorflow 2.14.1 , and Pydantic . This environment supports the following libraries:

absl-py                                 2.1.0
accelerate                              0.30.1
adagio                                  0.2.4
aesara                                  2.9.3
aiohttp                                 3.9.5
aiosignal                               1.3.1
aiosqlite                               0.20.0
alibi-detect                            0.12.0
alphalens-reloaded                      0.4.3
altair                                  5.2.0
aniso8601                               9.0.1
annotated-types                         0.7.0
antlr4-python3-runtime                  4.9.3
anyio                                   4.4.0
appdirs                                 1.4.4
apricot-select                          0.6.1
arch                                    6.3.0
argon2-cffi                             23.1.0
argon2-cffi-bindings                    21.2.0
arrow                                   1.3.0
arviz                                   0.18.0
astropy                                 6.0.0
astropy-iers-data                       0.2024.6.3.0.31.14
asttokens                               2.4.1
astunparse                              1.6.3
async-generator                         1.10
async-lru                               2.0.4
Authlib                                 1.3.0
autograd                                1.6.2
autograd-gamma                          0.5.0
autokeras                               1.1.0
autoray                                 0.6.12
ax-platform                             0.3.7
Babel                                   2.15.0
bayesian-optimization                   1.4.3
beautifulsoup4                          4.12.3
bleach                                  6.1.0
blis                                    0.7.11
blosc2                                  2.6.2
bokeh                                   3.3.4
botorch                                 0.10.0
Bottleneck                              1.3.8
cachetools                              5.3.3
captum                                  0.7.0
catalogue                               2.0.10
catboost                                1.2.3
category-encoders                       2.6.3
causal-conv1d                           1.2.0.post2
certipy                                 0.1.3
chardet                                 5.2.0
check-shapes                            1.1.1
clarabel                                0.9.0
click                                   8.1.7
clikit                                  0.6.2
cloudpathlib                            0.16.0
cloudpickle                             3.0.0
clr-loader                              0.1.6
cmdstanpy                               1.2.1
colorama                                0.4.6
colorcet                                3.1.0
colorlog                                6.8.2
colorlover                              0.3.0
colour                                  0.1.5
comm                                    0.2.2
confection                              0.1.5
cons                                    0.4.6
contourpy                               1.2.0
control                                 0.9.4
copulae                                 0.7.9
copulas                                 0.10.1
coreforecast                            0.0.9
cramjam                                 2.8.3
crashtest                               0.3.1
creme                                   0.6.1
cufflinks                               0.17.3
cvxopt                                  1.3.2
cvxpy                                   1.4.2
cycler                                  0.12.1
cymem                                   2.0.8
Cython                                  3.0.9
darts                                   0.28.0
dash                                    2.17.0
dash-core-components                    2.0.0
dash-cytoscape                          1.0.1
dash-html-components                    2.0.0
dash-table                              5.0.0
dask                                    2024.3.1
dask-expr                               1.0.5
dataclasses-json                        0.6.6
datasets                                2.17.1
deap                                    1.4.1
debugpy                                 1.8.1
decorator                               5.1.1
deepmerge                               1.1.1
defusedxml                              0.7.1
Deprecated                              1.2.14
deprecation                             2.1.0
dgl                                     2.1.0
dill                                    0.3.8
dimod                                   0.12.14
dirtyjson                               1.0.8
diskcache                               5.6.3
distributed                             2024.3.1
dm-tree                                 0.1.8
docker                                  7.1.0
docutils                                0.20.1
DoubleML                                0.7.1
dropstackframe                          0.1.0
dtreeviz                                2.2.2
dtw-python                              1.3.1
dwave-cloud-client                      0.11.3
dwave-drivers                           0.4.4
dwave-greedy                            0.3.0
dwave-hybrid                            0.6.11
dwave-inspector                         0.4.4
dwave-inspectorapp                      0.3.1
dwave-neal                              0.6.0
dwave-networkx                          0.8.14
dwave-ocean-sdk                         6.9.0
dwave-preprocessing                     0.6.5
dwave-samplers                          1.2.0
dwave-system                            1.23.0
dwave-tabu                              0.5.0
dwavebinarycsp                          0.3.0
ecos                                    2.0.13
einops                                  0.7.0
EMD-signal                              1.6.0
empyrical-reloaded                      0.5.10
en-core-web-md                          3.7.1
en-core-web-sm                          3.7.1
et-xmlfile                              1.1.0
etuples                                 0.3.9
exchange_calendars                      4.5.4
executing                               2.0.1
faiss-cpu                               1.8.0
Farama-Notifications                    0.0.4
fastai                                  2.7.14
fastai2                                 0.0.30
fastcore                                1.5.43
fastdownload                            0.0.7
fasteners                               0.19
fastjsonschema                          2.19.1
fastparquet                             2024.2.0
fastprogress                            1.0.3
fasttext                                0.9.2
feature-engine                          1.6.2
featuretools                            1.30.0
filelock                                3.14.0
findiff                                 0.10.0
FixedEffectModel                        0.0.5
FlagEmbedding                           1.2.10
FLAML                                   2.1.2
Flask                                   3.0.3
flatbuffers                             24.3.25
fonttools                               4.53.0
formulaic                               1.0.1
fqdn                                    1.5.1
frozendict                              2.4.4
frozenlist                              1.4.1
fs                                      2.4.16
fsspec                                  2023.10.0
fugue                                   0.9.0
functime                                0.9.5
future                                  1.0.0
fuzzy-c-means                           1.7.2
gast                                    0.5.4
gensim                                  4.3.2
gevent                                  24.2.1
gitdb                                   4.0.11
GitPython                               3.1.43
gluonts                                 0.14.4
google-auth                             2.29.0
google-auth-oauthlib                    1.0.0
google-pasta                            0.2.0
gpflow                                  2.9.1
gplearn                                 0.4.2
gpytorch                                1.11
graphene                                3.3
graphql-core                            3.2.3
graphql-relay                           3.2.0
graphviz                                0.20.1
grpcio                                  1.64.1
gunicorn                                21.2.0
gym                                     0.26.2
gym-notices                             0.0.8
gymnasium                               0.28.1
h11                                     0.14.0
h2o                                     3.46.0.1
h5netcdf                                1.3.0
h5py                                    3.11.0
hmmlearn                                0.3.2
holidays                                0.50
holoviews                               1.18.3
homebase                                1.0.1
hopcroftkarp                            1.2.5
html5lib                                1.1
httpcore                                1.0.5
httpstan                                4.12.0
httpx                                   0.27.0
huggingface-hub                         0.23.2
hurst                                   0.0.5
hvplot                                  0.9.2
hydra-core                              1.3.0
hyperopt                                0.2.7
ibm-cloud-sdk-core                      3.20.1
ibm-platform-services                   0.53.7
iisignature                             0.24
ijson                                   3.2.3
imageio                                 2.34.1
imbalanced-learn                        0.12.0
immutabledict                           4.2.0
importlib-metadata                      4.13.0
iniconfig                               2.0.0
injector                                0.21.0
interface-meta                          1.3.0
interpret                               0.5.1
interpret-core                          0.5.1
ipykernel                               6.29.4
ipython                                 8.25.0
ipywidgets                              8.1.2
isoduration                             20.11.0
itsdangerous                            2.2.0
jax                                     0.4.25
jax-jumpy                               1.0.0
jaxlib                                  0.4.25
jaxtyping                               0.2.29
jedi                                    0.19.1
joblib                                  1.3.2
json5                                   0.9.25
jsonpatch                               1.33
jsonpath-ng                             1.6.1
jsonpointer                             2.1
jupyter                                 1.0.0
jupyter-console                         6.6.3
jupyter-events                          0.10.0
jupyter-lsp                             2.2.5
jupyter-resource-usage                  1.0.2
jupyter_ai                              2.12.0
jupyter_ai_magics                       2.16.0
jupyter_bokeh                           4.0.0
jupyter_client                          8.6.2
jupyter_core                            5.7.2
jupyter_server                          2.14.1
jupyter_server_terminals                0.5.3
jupyterlab                              4.1.5
jupyterlab_pygments                     0.3.0
jupyterlab_server                       2.27.2
jupyterlab_widgets                      3.0.11
kagglehub                               0.2.5
kaleido                                 0.2.1
keras                                   2.14.0
keras-core                              0.1.7
keras-nlp                               0.12.1
keras-rl                                0.4.2
keras-tcn                               3.5.0
keras-tuner                             1.4.7
kiwisolver                              1.4.5
kmapper                                 2.0.1
korean-lunar-calendar                   0.3.1
kt-legacy                               1.0.5
langchain                               0.1.12
langchain-community                     0.0.38
langchain-core                          0.1.52
langchain-text-splitters                0.0.2
langcodes                               3.4.0
langsmith                               0.1.67
language_data                           1.2.0
lark                                    1.1.9
lazy_loader                             0.4
lazypredict-nightly                     0.3.0
libclang                                18.1.1
lifelines                               0.28.0
lightgbm                                4.3.0
lightning                               2.2.5
lightning-utilities                     0.11.2
lime                                    0.2.0.1
line-profiler                           4.1.2
linear-operator                         0.5.1
linkify-it-py                           2.0.3
livelossplot                            0.5.5
llama-index                             0.10.19
llama-index-agent-openai                0.1.7
llama-index-cli                         0.1.12
llama-index-core                        0.10.43
llama-index-embeddings-openai           0.1.10
llama-index-indices-managed-llama-cloud 0.1.6
llama-index-legacy                      0.9.48
llama-index-llms-openai                 0.1.22
llama-index-multi-modal-llms-openai     0.1.6
llama-index-program-openai              0.1.6
llama-index-question-gen-openai         0.1.3
llama-index-readers-file                0.1.23
llama-index-readers-llama-parse         0.1.4
llama-parse                             0.4.4
llamaindex-py-client                    0.1.19
llvmlite                                0.42.0
locket                                  1.0.0
logical-unification                     0.4.6
lxml                                    5.1.0
lz4                                     4.3.3
mamba-ssm                               1.2.0.post1
MAPIE                                   0.8.3
marisa-trie                             1.1.1
Markdown                                3.6
markdown-it-py                          3.0.0
marshmallow                             3.21.2
matplotlib                              3.7.5
matplotlib-inline                       0.1.7
mdit-py-plugins                         0.4.1
mdurl                                   0.1.2
mgarch                                  0.3.0
miniKanren                              1.0.3
minorminer                              0.2.13
mistune                                 3.0.2
ml-dtypes                               0.2.0
mlflow                                  2.11.1
mlforecast                              0.12.0
mljar-supervised                        1.1.6
mlxtend                                 0.23.1
mmh3                                    2.5.1
modin                                   0.26.1
mplfinance                              0.12.10b0
mpmath                                  1.3.0
msgpack                                 1.0.8
multidict                               6.0.5
multipledispatch                        1.0.0
multiprocess                            0.70.16
multitasking                            0.0.11
murmurhash                              1.0.10
mypy-extensions                         1.0.0
namex                                   0.0.8
nbclient                                0.10.0
nbconvert                               7.16.4
nbformat                                5.10.4
ndindex                                 1.8
nest-asyncio                            1.6.0
networkx                                3.3
neural-tangents                         0.6.5
neuralprophet                           0.8.0
nfoursid                                1.0.1
ngboost                                 0.5.1
ninja                                   1.11.1.1
nixtlats                                0.2.0
nltk                                    3.8.1
nolds                                   0.5.2
nose                                    1.3.7
notebook                                7.1.3
notebook_shim                           0.2.4
numba                                   0.59.0
numerapi                                2.18.0
numexpr                                 2.10.0
numpy                                   1.26.4
nvidia-cublas-cu12                      12.5.2.13
nvidia-cuda-cupti-cu12                  12.1.105
nvidia-cuda-nvrtc-cu12                  12.1.105
nvidia-cuda-runtime-cu12                12.1.105
nvidia-cudnn-cu12                       8.9.2.26
nvidia-cufft-cu12                       11.0.2.54
nvidia-curand-cu12                      10.3.2.106
nvidia-cusolver-cu12                    11.4.5.107
nvidia-cusparse-cu12                    12.1.0.106
nvidia-nccl-cu12                        2.19.3
nvidia-nvjitlink-cu12                   12.5.40
nvidia-nvtx-cu12                        12.1.105
omegaconf                               2.3.0
openai                                  1.30.4
opencv-contrib-python-headless          4.9.0.80
opencv-python                           4.10.0.82
openpyxl                                3.1.2
opt-einsum                              3.3.0
optree                                  0.11.0
optuna                                  3.5.0
orjson                                  3.10.3
ortools                                 9.9.3963
osqp                                    0.6.7
overrides                               7.7.0
packaging                               23.2
pandas                                  2.1.4
pandas-flavor                           0.6.0
pandas-ta                               0.3.14b0
pandas_market_calendars                 4.4.0
pandocfilters                           1.5.1
panel                                   1.3.8
param                                   2.1.0
parso                                   0.8.4
partd                                   1.4.2
pastel                                  0.2.1
pathos                                  0.3.2
patsy                                   0.5.6
pbr                                     6.0.0
pearl                                   2.3.12
peewee                                  3.17.3
peft                                    0.11.1
penaltymodel                            1.1.0
PennyLane                               0.35.1
PennyLane-qiskit                        0.35.1
PennyLane_Lightning                     0.35.1
persim                                  0.3.5
pexpect                                 4.9.0
pgmpy                                   0.1.25
pillow                                  10.3.0
pingouin                                0.5.4
plotly                                  5.20.0
plotly-resampler                        0.10.0
plucky                                  0.4.3
pluggy                                  1.5.0
ply                                     3.11
pmdarima                                2.0.4
polars                                  0.20.15
pomegranate                             1.0.4
POT                                     0.9.3
pox                                     0.3.4
ppft                                    1.7.6.8
pprofile                                2.1.0
preshed                                 3.0.9
prompt_toolkit                          3.0.45
prophet                                 1.1.5
protobuf                                4.25.3
ptyprocess                              0.7.0
PuLP                                    2.8.0
pure-eval                               0.2.2
py-cpuinfo                              9.0.0
py-heat                                 0.0.6
py-heat-magic                           0.0.2
py-lets-be-rational                     1.0.1
py-vollib                               1.0.1
py4j                                    0.10.9.7
pyaml                                   24.4.0
pyarrow                                 15.0.1
pyarrow-hotfix                          0.6
pyasn1                                  0.6.0
pyasn1_modules                          0.4.0
pybind11                                2.12.0
pycaret                                 3.3.2
pycparser                               2.20
pydantic                                1.10.15
pydantic_core                           2.18.4
pydmd                                   1.0.0
pyerfa                                  2.0.1.4
pyfolio-reloaded                        0.9.5
Pygments                                2.18.0
pykalman                                0.9.7
pylev                                   1.4.0
pyluach                                 2.2.0
pymannkendall                           1.4.3
pymc                                    5.10.4
pymdptoolbox                            4.0b3
pynndescent                             0.5.12
pyod                                    2.0.0
Pyomo                                   6.7.1
pyparsing                               3.1.2
pypdf                                   4.2.0
pyportfolioopt                          1.5.5
pyre-extensions                         0.0.30
pyro-api                                0.1.2
pyro-ppl                                1.9.0
pysimdjson                              5.0.2
pyspnego                                0.10.2
pystan                                  3.9.0
pytensor                                2.18.6
pytest                                  8.2.1
python-dotenv                           1.0.0
python-statemachine                     2.1.2
pytorch-ignite                          0.4.13
pytorch-lightning                       1.9.5
pytorch-tabnet                          4.1.0
pytz                                    2024.1
pyvinecopulib                           0.6.5
pyviz_comms                             3.0.2
PyWavelets                              1.5.0
PyYAML                                  6.0.1
pyzmq                                   26.0.3
qdldl                                   0.1.7.post2
qiskit                                  1.0.2
qiskit-aer                              0.14.2
qiskit-ibm-provider                     0.11.0
qiskit-ibm-runtime                      0.20.0
qtconsole                               5.5.2
QtPy                                    2.4.1
quadprog                                0.1.12
quantconnect-stubs                      16467
quantecon                               0.7.2
QuantLib                                1.33
QuantStats                              0.0.62
querystring-parser                      1.2.4
rauth                                   0.7.3
ray                                     2.9.3
Rbeast                                  0.1.19
rectangle-packer                        2.0.2
regex                                   2024.5.15
requests-ntlm                           1.2.0
requests-oauthlib                       1.3.1
retrying                                1.3.4
rfc3339-validator                       0.1.4
rfc3986-validator                       0.1.1
rich                                    13.7.1
ripser                                  0.6.8
Riskfolio-Lib                           6.0.0
riskparityportfolio                     0.5.1
river                                   0.21.0
rsa                                     4.9
ruptures                                1.1.9
rustworkx                               0.14.2
safetensors                             0.4.3
SALib                                   1.5.0
schemdraw                               0.15
scikeras                                0.13.0
scikit-base                             0.7.8
scikit-image                            0.22.0
scikit-learn                            1.4.2
scikit-learn-extra                      0.3.0
scikit-optimize                         0.10.0
scikit-plot                             0.3.7
scikit-tda                              1.0.0
scipy                                   1.11.4
scs                                     3.2.4.post2
sdeint                                  0.3.0
seaborn                                 0.13.2
semantic-version                        2.10.0
Send2Trash                              1.8.3
sentence-transformers                   3.0.0
setuptools-scm                          8.1.0
shap                                    0.45.0
Shimmy                                  1.3.0
simplejson                              3.19.2
simpy                                   4.1.1
sklearn-json                            0.1.0
sktime                                  0.26.0
slicer                                  0.0.7
smart-open                              6.4.0
smmap                                   5.0.1
sniffio                                 1.3.1
sortedcontainers                        2.4.0
soupsieve                               2.5
spacy                                   3.7.4
spacy-legacy                            3.0.12
spacy-loggers                           1.0.5
sqlparse                                0.5.0
srsly                                   2.4.8
stable_baselines3                       2.3.2
stack-data                              0.6.3
stanio                                  0.3.0
statsforecast                           1.7.5
statsmodels                             0.14.1
stevedore                               5.2.0
stochastic                              0.6.0
stockstats                              0.6.2
stopit                                  1.1.2
striprtf                                0.0.26
stumpy                                  1.12.0
symengine                               0.11.0
sympy                                   1.12.1
ta                                      0.11.0
TA-Lib                                  0.4.28
tables                                  3.9.2
tabulate                                0.8.10
tadasets                                0.2.1
tbats                                   1.1.3
tblib                                   3.0.0
tenacity                                8.3.0
tensorboard                             2.14.1
tensorboard-data-server                 0.7.2
tensorboardX                            2.6.2.2
tensorflow                              2.14.1
tensorflow-addons                       0.23.0
tensorflow-estimator                    2.14.0
tensorflow-hub                          0.16.1
tensorflow-io-gcs-filesystem            0.37.0
tensorflow-probability                  0.24.0
tensorflow-ranking                      0.5.3
tensorflow-serving-api                  2.14.1
tensorflow-text                         2.14.0
tensorflow_decision_forests             1.9.0
tensorly                                0.8.1
tensorrt                                8.6.1.post1
tensorrt-bindings                       8.6.1
tensorrt-libs                           8.6.1
tensortrade                             1.0.3
termcolor                               2.4.0
terminado                               0.18.1
tf-keras                                2.15.0
tf2jax                                  0.3.6
thinc                                   8.2.3
threadpoolctl                           3.5.0
thundergbm                              0.3.17
tifffile                                2024.5.22
tiktoken                                0.7.0
tinycss2                                1.3.0
tokenizers                              0.19.1
toml                                    0.10.2
toolz                                   0.12.1
torch                                   2.2.1
torch-cluster                           1.6.3
torch-scatter                           2.1.2
torch-sparse                            0.6.18
torch-spline-conv                       1.2.2
torch_geometric                         2.5.1
torchdata                               0.7.1
torchmetrics                            1.4.0.post0
torchvision                             0.17.1
TPOT                                    0.12.2
tqdm                                    4.66.4
transformers                            4.40.2
triad                                   0.9.6
triton                                  2.2.0
tsdownsample                            0.1.3
tsfresh                                 0.20.2
tslearn                                 0.6.3
tweepy                                  4.14.0
typeguard                               2.13.3
typer                                   0.9.4
typer-config                            1.4.0
types-python-dateutil                   2.9.0.20240316
typing-inspect                          0.9.0
tzdata                                  2024.1
uc-micro-py                             1.0.3
umap-learn                              0.5.5
update-checker                          0.18.0
uri-template                            1.3.0
utilsforecast                           0.1.10
wasabi                                  1.1.3
wcwidth                                 0.2.13
weasel                                  0.3.4
webargs                                 8.4.0
webcolors                               1.13
webencodings                            0.5.1
websocket-client                        1.8.0
websockets                              12.0
Werkzeug                                3.0.1
widgetsnbextension                      4.0.11
window_ops                              0.0.15
woodwork                                0.31.0
wordcloud                               1.9.3
wrapt                                   1.14.1
wurlitzer                               3.1.0
x-transformers                          1.30.4
xarray                                  2024.2.0
xarray-einstats                         0.7.0
xgboost                                 2.0.3
xlrd                                    2.0.1
XlsxWriter                              3.2.0
xxhash                                  3.4.1
xyzservices                             2024.4.0
yarl                                    1.9.4
yellowbrick                             1.5
yfinance                                0.2.40
zict                                    3.0.0
zope.event                              5.0
zope.interface                          6.4.post2

Autogluon Environment Libraries

This environment is only available for Python.

The Autogluon environment provides the following libraries:

absl-py                                 2.1.0
accelerate                              0.21.0
adagio                                  0.2.4
aesara                                  2.9.3
aiohttp                                 3.9.5
aiohttp-cors                            0.7.0
aiosignal                               1.3.1
aiosqlite                               0.20.0
alibi-detect                            0.12.0
aliyun-python-sdk-core                  2.15.1
aliyun-python-sdk-kms                   2.16.3
alphalens-reloaded                      0.4.3
altair                                  5.2.0
aniso8601                               9.0.1
annotated-types                         0.7.0
antlr4-python3-runtime                  4.9.3
anyio                                   4.4.0
appdirs                                 1.4.4
apricot-select                          0.6.1
arch                                    6.3.0
argon2-cffi                             23.1.0
argon2-cffi-bindings                    21.2.0
arrow                                   1.3.0
arviz                                   0.18.0
astropy                                 6.0.0
astropy-iers-data                       0.2024.6.3.0.31.14
asttokens                               2.4.1
astunparse                              1.6.3
async-generator                         1.10
async-lru                               2.0.4
Authlib                                 1.3.0
autogluon                               1.1.0
autogluon.common                        1.1.0
autogluon.core                          1.1.0
autogluon.features                      1.1.0
autogluon.multimodal                    1.1.0
autogluon.tabular                       1.1.0
autogluon.timeseries                    1.1.0
autograd                                1.6.2
autograd-gamma                          0.5.0
autokeras                               2.0.0
autoray                                 0.6.12
ax-platform                             0.3.7
Babel                                   2.15.0
bayesian-optimization                   1.4.3
beautifulsoup4                          4.12.3
bleach                                  6.1.0
blis                                    0.7.11
blosc2                                  2.6.2
bokeh                                   3.3.4
boto3                                   1.34.118
botocore                                1.34.118
botorch                                 0.10.0
Bottleneck                              1.3.8
cachetools                              5.3.3
captum                                  0.7.0
catalogue                               2.0.10
catboost                                1.2.3
category-encoders                       2.6.3
causal-conv1d                           1.2.0.post2
certipy                                 0.1.3
chardet                                 5.2.0
check-shapes                            1.1.1
clarabel                                0.9.0
click                                   8.1.7
clikit                                  0.6.2
cloudpathlib                            0.16.0
cloudpickle                             3.0.0
clr-loader                              0.1.6
cmdstanpy                               1.2.1
colorama                                0.4.6
colorcet                                3.1.0
coloredlogs                             15.0.1
colorful                                0.5.6
colorlog                                6.8.2
colorlover                              0.3.0
colour                                  0.1.5
comm                                    0.2.2
confection                              0.1.5
cons                                    0.4.6
contourpy                               1.2.0
control                                 0.9.4
copulae                                 0.7.9
copulas                                 0.10.1
coreforecast                            0.0.9
cramjam                                 2.8.3
crashtest                               0.3.1
crcmod                                  1.7
creme                                   0.6.1
cufflinks                               0.17.3
cvxopt                                  1.3.2
cvxpy                                   1.4.2
cycler                                  0.12.1
cymem                                   2.0.8
Cython                                  3.0.9
darts                                   0.28.0
dash                                    2.17.0
dash-core-components                    2.0.0
dash-cytoscape                          1.0.1
dash-html-components                    2.0.0
dash-table                              5.0.0
dask                                    2024.3.1
dask-expr                               1.0.5
dataclasses-json                        0.6.6
datasets                                2.17.1
deap                                    1.4.1
debugpy                                 1.8.1
decorator                               5.1.1
deepmerge                               1.1.1
defusedxml                              0.7.1
Deprecated                              1.2.14
deprecation                             2.1.0
dgl                                     2.1.0
dill                                    0.3.8
dimod                                   0.12.14
dirtyjson                               1.0.8
diskcache                               5.6.3
distlib                                 0.3.8
distributed                             2024.3.1
dm-tree                                 0.1.8
docker                                  7.1.0
docutils                                0.20.1
DoubleML                                0.7.1
dropstackframe                          0.1.0
dtreeviz                                2.2.2
dtw-python                              1.3.1
dwave-cloud-client                      0.11.3
dwave-drivers                           0.4.4
dwave-greedy                            0.3.0
dwave-hybrid                            0.6.11
dwave-inspector                         0.4.4
dwave-inspectorapp                      0.3.1
dwave-neal                              0.6.0
dwave-networkx                          0.8.14
dwave-ocean-sdk                         6.9.0
dwave-preprocessing                     0.6.5
dwave-samplers                          1.2.0
dwave-system                            1.23.0
dwave-tabu                              0.5.0
dwavebinarycsp                          0.3.0
ecos                                    2.0.13
einops                                  0.7.0
EMD-signal                              1.6.0
empyrical-reloaded                      0.5.10
en-core-web-md                          3.7.1
en-core-web-sm                          3.7.1
et-xmlfile                              1.1.0
etuples                                 0.3.9
evaluate                                0.4.2
exchange_calendars                      4.5.4
executing                               2.0.1
faiss-cpu                               1.8.0
Farama-Notifications                    0.0.4
fastai                                  2.7.14
fastai2                                 0.0.30
fastcore                                1.5.43
fastdownload                            0.0.7
fasteners                               0.19
fastjsonschema                          2.19.1
fastparquet                             2024.2.0
fastprogress                            1.0.3
fasttext                                0.9.2
feature-engine                          1.6.2
featuretools                            1.30.0
filelock                                3.14.0
findiff                                 0.10.0
FixedEffectModel                        0.0.5
FlagEmbedding                           1.2.10
FLAML                                   2.1.2
Flask                                   3.0.3
flatbuffers                             24.3.25
fonttools                               4.53.0
formulaic                               1.0.1
fqdn                                    1.5.1
frozendict                              2.4.4
frozenlist                              1.4.1
fs                                      2.4.16
fsspec                                  2023.10.0
fugue                                   0.9.0
functime                                0.9.5
future                                  1.0.0
fuzzy-c-means                           1.7.2
gast                                    0.5.4
gdown                                   5.2.0
gensim                                  4.3.2
gevent                                  24.2.1
gitdb                                   4.0.11
GitPython                               3.1.43
gluonts                                 0.14.3
google-api-core                         2.19.0
google-auth                             2.29.0
google-pasta                            0.2.0
googleapis-common-protos                1.63.1
gpflow                                  2.9.1
gplearn                                 0.4.2
gpytorch                                1.11
graphene                                3.3
graphql-core                            3.2.3
graphql-relay                           3.2.0
graphviz                                0.20.1
grpcio                                  1.64.1
gunicorn                                21.2.0
gym                                     0.26.2
gym-notices                             0.0.8
gymnasium                               0.28.1
h11                                     0.14.0
h2o                                     3.46.0.1
h5netcdf                                1.3.0
h5py                                    3.11.0
hmmlearn                                0.3.2
holidays                                0.50
holoviews                               1.18.3
homebase                                1.0.1
hopcroftkarp                            1.2.5
html5lib                                1.1
httpcore                                1.0.5
httpstan                                4.12.0
httpx                                   0.27.0
huggingface-hub                         0.23.2
humanfriendly                           10.0
hurst                                   0.0.5
hvplot                                  0.9.2
hydra-core                              1.3.0
hyperopt                                0.2.7
ibm-cloud-sdk-core                      3.20.1
ibm-platform-services                   0.53.7
iisignature                             0.24
ijson                                   3.2.3
imageio                                 2.34.1
imbalanced-learn                        0.12.0
immutabledict                           4.2.0
iniconfig                               2.0.0
injector                                0.21.0
interface-meta                          1.3.0
interpret                               0.5.1
interpret-core                          0.5.1
ipykernel                               6.29.4
ipython                                 8.25.0
ipywidgets                              8.1.2
isoduration                             20.11.0
itsdangerous                            2.2.0
jax                                     0.4.25
jax-jumpy                               1.0.0
jaxlib                                  0.4.25
jaxtyping                               0.2.29
jedi                                    0.19.1
jmespath                                0.10.0
joblib                                  1.3.2
json5                                   0.9.25
jsonpatch                               1.33
jsonpath-ng                             1.6.1
jsonpointer                             2.1
jupyter                                 1.0.0
jupyter-console                         6.6.3
jupyter-events                          0.10.0
jupyter-lsp                             2.2.5
jupyter-resource-usage                  1.0.2
jupyter_ai                              2.12.0
jupyter_ai_magics                       2.16.0
jupyter_bokeh                           4.0.0
jupyter_client                          8.6.2
jupyter_core                            5.7.2
jupyter_server                          2.14.1
jupyter_server_terminals                0.5.3
jupyterlab                              4.1.5
jupyterlab_pygments                     0.3.0
jupyterlab_server                       2.27.2
jupyterlab_widgets                      3.0.11
kagglehub                               0.2.5
kaleido                                 0.2.1
keras                                   3.3.3
keras-core                              0.1.7
keras-nlp                               0.12.1
keras-rl                                0.4.2
keras-tcn                               3.5.0
keras-tuner                             1.4.7
kiwisolver                              1.4.5
kmapper                                 2.0.1
korean-lunar-calendar                   0.3.1
kt-legacy                               1.0.5
langchain                               0.1.12
langchain-community                     0.0.38
langchain-core                          0.1.52
langchain-text-splitters                0.0.2
langcodes                               3.4.0
langsmith                               0.1.67
language_data                           1.2.0
lark                                    1.1.9
lazy_loader                             0.4
lazypredict-nightly                     0.3.0
libclang                                18.1.1
lifelines                               0.28.0
lightgbm                                4.3.0
lightning                               2.1.4
lightning-utilities                     0.11.2
lime                                    0.2.0.1
line-profiler                           4.1.2
linear-operator                         0.5.1
linkify-it-py                           2.0.3
livelossplot                            0.5.5
llama-index                             0.10.19
llama-index-agent-openai                0.1.7
llama-index-cli                         0.1.12
llama-index-core                        0.10.43
llama-index-embeddings-openai           0.1.10
llama-index-indices-managed-llama-cloud 0.1.6
llama-index-legacy                      0.9.48
llama-index-llms-openai                 0.1.22
llama-index-multi-modal-llms-openai     0.1.6
llama-index-program-openai              0.1.6
llama-index-question-gen-openai         0.1.3
llama-index-readers-file                0.1.23
llama-index-readers-llama-parse         0.1.4
llama-parse                             0.4.4
llamaindex-py-client                    0.1.19
llvmlite                                0.42.0
locket                                  1.0.0
logical-unification                     0.4.6
lxml                                    5.1.0
lz4                                     4.3.3
mamba-ssm                               1.2.0.post1
MAPIE                                   0.8.3
marisa-trie                             1.1.1
Markdown                                3.6
markdown-it-py                          3.0.0
marshmallow                             3.21.2
matplotlib                              3.7.5
matplotlib-inline                       0.1.7
mdit-py-plugins                         0.4.1
mdurl                                   0.1.2
mgarch                                  0.3.0
miniKanren                              1.0.3
minorminer                              0.2.13
mistune                                 3.0.2
ml-dtypes                               0.3.2
mlflow                                  2.11.1
mlforecast                              0.10.0
mljar-supervised                        1.1.6
mlxtend                                 0.23.1
mmh3                                    2.5.1
model-index                             0.1.11
modin                                   0.26.1
mplfinance                              0.12.10b0
mpmath                                  1.3.0
msgpack                                 1.0.8
multidict                               6.0.5
multipledispatch                        1.0.0
multiprocess                            0.70.16
multitasking                            0.0.11
murmurhash                              1.0.10
mypy-extensions                         1.0.0
namex                                   0.0.8
nbclient                                0.10.0
nbconvert                               7.16.4
nbformat                                5.10.4
ndindex                                 1.8
nest-asyncio                            1.6.0
networkx                                3.3
neural-tangents                         0.6.5
neuralprophet                           0.8.0
nfoursid                                1.0.1
ngboost                                 0.5.1
ninja                                   1.11.1.1
nlpaug                                  1.1.11
nltk                                    3.8.1
nolds                                   0.5.2
nose                                    1.3.7
notebook                                7.1.3
notebook_shim                           0.2.4
nptyping                                2.4.1
numba                                   0.59.0
numerapi                                2.18.0
numexpr                                 2.10.0
numpy                                   1.26.4
nvidia-cublas-cu12                      12.5.2.13
nvidia-cuda-cupti-cu12                  12.1.105
nvidia-cuda-nvrtc-cu12                  12.1.105
nvidia-cuda-runtime-cu12                12.1.105
nvidia-cudnn-cu12                       8.9.2.26
nvidia-cufft-cu12                       11.0.2.54
nvidia-curand-cu12                      10.3.2.106
nvidia-cusolver-cu12                    11.4.5.107
nvidia-cusparse-cu12                    12.1.0.106
nvidia-ml-py3                           7.352.0
nvidia-nccl-cu12                        2.18.1
nvidia-nvjitlink-cu12                   12.5.40
nvidia-nvtx-cu12                        12.1.105
omegaconf                               2.2.3
onnx                                    1.16.1
onnxruntime                             1.18.0
openai                                  1.30.4
opencensus                              0.11.4
opencensus-context                      0.1.3
opencv-contrib-python-headless          4.9.0.80
opencv-python                           4.10.0.82
opendatalab                             0.0.10
openmim                                 0.3.9
openpyxl                                3.1.2
openxlab                                0.1.0
opt-einsum                              3.3.0
optimum                                 1.18.1
optree                                  0.11.0
optuna                                  3.5.0
ordered-set                             4.1.0
orjson                                  3.10.3
ortools                                 9.9.3963
osqp                                    0.6.7
oss2                                    2.17.0
overrides                               7.7.0
packaging                               24.0
pandas                                  2.1.4
pandas-flavor                           0.6.0
pandas-ta                               0.3.14b0
pandas_market_calendars                 4.4.0
pandocfilters                           1.5.1
panel                                   1.3.8
param                                   2.1.0
parso                                   0.8.4
partd                                   1.4.2
pastel                                  0.2.1
pathos                                  0.3.2
patsy                                   0.5.6
pbr                                     6.0.0
pdf2image                               1.17.0
peewee                                  3.17.3
peft                                    0.11.1
penaltymodel                            1.1.0
PennyLane                               0.35.1
PennyLane-qiskit                        0.35.1
PennyLane_Lightning                     0.35.1
persim                                  0.3.5
pexpect                                 4.9.0
pgmpy                                   0.1.25
pillow                                  10.3.0
pingouin                                0.5.4
plotly                                  5.20.0
plotly-resampler                        0.10.0
plucky                                  0.4.3
pluggy                                  1.5.0
ply                                     3.11
pmdarima                                2.0.4
polars                                  0.20.15
pomegranate                             1.0.4
POT                                     0.9.3
pox                                     0.3.4
ppft                                    1.7.6.8
pprofile                                2.1.0
preshed                                 3.0.9
prompt_toolkit                          3.0.45
prophet                                 1.1.5
proto-plus                              1.23.0
protobuf                                4.25.3
ptyprocess                              0.7.0
PuLP                                    2.8.0
pure-eval                               0.2.2
py-cpuinfo                              9.0.0
py-heat                                 0.0.6
py-heat-magic                           0.0.2
py-lets-be-rational                     1.0.1
py-spy                                  0.3.14
py-vollib                               1.0.1
py4j                                    0.10.9.7
pyaml                                   24.4.0
pyarrow                                 15.0.1
pyarrow-hotfix                          0.6
pyasn1                                  0.6.0
pyasn1_modules                          0.4.0
pybind11                                2.12.0
pycaret                                 3.3.2
pycparser                               2.20
pycryptodome                            3.20.0
pydantic                                2.7.3
pydantic_core                           2.18.4
pydmd                                   1.0.0
pyerfa                                  2.0.1.4
pyfolio-reloaded                        0.9.5
Pygments                                2.18.0
pykalman                                0.9.7
pylev                                   1.4.0
pyluach                                 2.2.0
pymannkendall                           1.4.3
pymc                                    5.10.4
pymdptoolbox                            4.0b3
pynndescent                             0.5.12
pyod                                    2.0.0
Pyomo                                   6.7.1
pyparsing                               3.1.2
pypdf                                   4.2.0
pyportfolioopt                          1.5.5
pyre-extensions                         0.0.30
pyro-api                                0.1.2
pyro-ppl                                1.9.0
pysimdjson                              5.0.2
pyspnego                                0.10.2
pystan                                  3.9.0
pytensor                                2.18.6
pytesseract                             0.3.10
pytest                                  8.2.1
python-dotenv                           1.0.0
python-statemachine                     2.1.2
pytorch-ignite                          0.4.13
pytorch-lightning                       2.1.4
pytorch-metric-learning                 2.3.0
pytorch-tabnet                          4.1.0
pytz                                    2023.4
pyvinecopulib                           0.6.5
pyviz_comms                             3.0.2
PyWavelets                              1.5.0
PyYAML                                  6.0.1
pyzmq                                   26.0.3
qdldl                                   0.1.7.post2
qiskit                                  1.0.2
qiskit-aer                              0.14.2
qiskit-ibm-provider                     0.11.0
qiskit-ibm-runtime                      0.20.0
qtconsole                               5.5.2
QtPy                                    2.4.1
quadprog                                0.1.12
quantconnect-stubs                      16467
quantecon                               0.7.2
QuantLib                                1.33
QuantStats                              0.0.62
querystring-parser                      1.2.4
rauth                                   0.7.3
ray                                     2.10.0
Rbeast                                  0.1.19
rectangle-packer                        2.0.2
regex                                   2024.5.15
requests                                2.28.2
requests-ntlm                           1.2.0
requests-oauthlib                       1.3.1
retrying                                1.3.4
rfc3339-validator                       0.1.4
rfc3986-validator                       0.1.1
rich                                    13.4.2
ripser                                  0.6.8
Riskfolio-Lib                           6.0.0
riskparityportfolio                     0.5.1
river                                   0.21.0
rsa                                     4.9
ruptures                                1.1.9
rustworkx                               0.14.2
s3transfer                              0.10.1
safetensors                             0.4.3
SALib                                   1.5.0
schemdraw                               0.15
scikeras                                0.13.0
scikit-base                             0.7.8
scikit-image                            0.20.0
scikit-learn                            1.4.0
scikit-learn-extra                      0.3.0
scikit-optimize                         0.10.0
scikit-plot                             0.3.7
scikit-tda                              1.0.0
scipy                                   1.11.4
scs                                     3.2.4.post2
sdeint                                  0.3.0
seaborn                                 0.13.2
semantic-version                        2.10.0
Send2Trash                              1.8.3
sentence-transformers                   3.0.0
sentencepiece                           0.2.0
seqeval                                 1.2.2
setuptools-scm                          8.1.0
shap                                    0.45.0
Shimmy                                  1.3.0
simplejson                              3.19.2
simpy                                   4.1.1
sklearn-json                            0.1.0
sktime                                  0.26.0
slicer                                  0.0.7
smart-open                              6.4.0
smmap                                   5.0.1
sniffio                                 1.3.1
sortedcontainers                        2.4.0
soupsieve                               2.5
spacy                                   3.7.4
spacy-legacy                            3.0.12
spacy-loggers                           1.0.5
sqlparse                                0.5.0
srsly                                   2.4.8
stable_baselines3                       2.3.2
stack-data                              0.6.3
stanio                                  0.3.0
statsforecast                           1.4.0
statsmodels                             0.14.1
stevedore                               5.2.0
stochastic                              0.6.0
stockstats                              0.6.2
stopit                                  1.1.2
striprtf                                0.0.26
stumpy                                  1.12.0
symengine                               0.11.0
sympy                                   1.12.1
ta                                      0.11.0
TA-Lib                                  0.4.28
tables                                  3.9.2
tabulate                                0.8.10
tadasets                                0.2.1
tbats                                   1.1.3
tblib                                   3.0.0
tenacity                                8.3.0
tensorboard                             2.16.2
tensorboard-data-server                 0.7.2
tensorboardX                            2.6.2.2
tensorflow                              2.16.1
tensorflow-addons                       0.23.0
tensorflow-io-gcs-filesystem            0.37.0
tensorflow-probability                  0.24.0
tensorflow-text                         2.16.1
tensorflow_decision_forests             1.9.0
tensorly                                0.8.1
tensorrt                                8.6.1.post1
tensorrt-bindings                       8.6.1
tensorrt-libs                           8.6.1
tensortrade                             1.0.3
termcolor                               2.4.0
terminado                               0.18.1
text-unidecode                          1.3
tf2jax                                  0.3.6
tf_keras                                2.16.0
thinc                                   8.2.3
threadpoolctl                           3.5.0
thundergbm                              0.3.17
tifffile                                2024.5.22
tiktoken                                0.7.0
timm                                    0.9.16
tinycss2                                1.3.0
tokenizers                              0.15.2
toml                                    0.10.2
toolz                                   0.12.1
torch                                   2.1.2
torch-cluster                           1.6.3
torch-scatter                           2.1.2
torch-sparse                            0.6.18
torch-spline-conv                       1.2.2
torch_geometric                         2.5.1
torchdata                               0.7.1
torchmetrics                            1.2.1
torchvision                             0.16.2
TPOT                                    0.12.2
tqdm                                    4.65.2
transformers                            4.38.2
triad                                   0.9.6
triton                                  2.1.0
tsdownsample                            0.1.3
tsfresh                                 0.20.2
tslearn                                 0.6.3
tweepy                                  4.14.0
typeguard                               2.13.3
typer                                   0.9.4
typer-config                            1.4.0
types-python-dateutil                   2.9.0.20240316
typing-inspect                          0.9.0
tzdata                                  2024.1
uc-micro-py                             1.0.3
umap-learn                              0.5.5
update-checker                          0.18.0
uri-template                            1.3.0
urllib3                                 1.26.18
utilsforecast                           0.0.10
virtualenv                              20.26.2
wasabi                                  1.1.3
wcwidth                                 0.2.13
weasel                                  0.3.4
webargs                                 8.4.0
webcolors                               1.13
webencodings                            0.5.1
websocket-client                        1.8.0
websockets                              12.0
Werkzeug                                3.0.1
widgetsnbextension                      4.0.11
window_ops                              0.0.15
woodwork                                0.31.0
wordcloud                               1.9.3
wrapt                                   1.16.0
wurlitzer                               3.1.0
x-transformers                          1.30.4
xarray                                  2024.2.0
xarray-einstats                         0.7.0
xgboost                                 2.0.3
xlrd                                    2.0.1
XlsxWriter                              3.2.0
xxhash                                  3.4.1
xyzservices                             2024.4.0
yarl                                    1.9.4
yellowbrick                             1.5
yfinance                                0.2.40
zict                                    3.0.0
zope.event                              5.0
zope.interface                          6.4.post2

Add New Libraries

To request a new library, contact us . We will add the library to the queue for review and deployment. Since the libraries run on our servers, we need to ensure they are secure and won't cause harm. The process of adding new libraries takes 2-4 weeks to complete. View the list of libraries currently under review on the Issues list of the Lean GitHub repository .

Project Libraries

Project libraries are QuantConnect projects you can merge into your project to avoid duplicating code files. If you have tools that you use across several projects, create a library.

The process to create a library depends on if you use the Cloud Platform , Local Platform , or CLI .

Key Concepts > Glossary

Introduction

This page defines terms in QuantConnect products and documentation.

alpha

The quantity of an algorithm's returns that aren't explained by its underlying benchmark.

annual standard deviation

A staticial measure that describes the dispersion of annual returns relative to the mean annual return. It's the square root of the annual variance.

annual variance

A staticial measure that describes the dispersion of annual returns relative to the mean annual return.

average loss

The average rate of return for unprofitable trades.

average win

The average rate of return for profitable trades.

beta

The scale and direction of an algorithm's returns relative to movements in the underlying benchmark.

capacity

The maximum amount of money an algorithm can trade before its performance degrades from market impact.

compounding annual return

The annual percentage return that would be required to grow a portfolio from its starting value to its ending value.

day trade

Buying and selling the same asset within one trading day.

drawdown

The largest peak to trough decline in an algorithm's equity curve.

equity

The total portfolio value if all of the holdings were sold at current market rates.

expectancy

The expected return per trade.

holdings

The absolute sum of the items in the portfolio.

information ratio

The amount of excess return from the risk-free rate per unit of systematic risk.

intrinsic value

(Call Option) The price of an asset minus the strike price if the price is above the strike price, otherwise zero.

(Put Option) The strike price minus the price of an asset if the price is below the strike price, otherwise zero.

look-ahead bias

The practice of making decisions using information that would not be available until some time in the future.

loss rate

The proportion of trades that were not profitable.

lowest capacity asset

The asset an algorithm traded that has the lowest capacity.

net profit

(Percent) The rate of return across the entire trading period.

(Dollar-value) The dollar-value return across the entire trading period.

out-of-the-money amount

(Call Option) The strike price minus the price of an asset if the price is below the strike price, otherwise zero.

(Put Option) The price of an asset minus the strike price if the price is above the strike price, otherwise zero.

payoff

The profit or loss that an Option buyer or seller makes from a trade.

pattern day trader

A trader who executes four or more day trades in the US Equity market within five business days.

Probabilistic Sharpe ratio

The probability that the estimated Sharpe ratio of an algorithm is greater than a benchmark (1).

profit-loss ratio

The ratio of the average win rate to the average loss rate.

return

The rate of return across the entire trading period.

risk-free interest rate

The interest rate an investor can expect to earn on an investment that carries zero risk such as the interest paid on a 10-year highly rated government treasury note

Sharpe ratio

A measure of the risk-adjusted return, developed by William Sharpe.

Sortino ratio

A measure of the risk-adjusted return, developed by Frank Sortino. It only penalizes returns falling below a user-specified target or required rate of return.

total fees

The total quantity of fees paid for all the transactions.

total net profit

The rate of return across the entire trading period.

total trades

The number of orders that were filled or partially filled.

tracking error

A measure of how closely a portfolio follows the index to which it is benchmarked. A tracking error of 0 is a perfect match.

Treynor ratio

A measurement of the returns earned in an algorithm in excess of the risk-free rate per unit of benchmark risk, developed by Jack Treynor.

unrealized

The amount of profit a portfolio would capture if it liquidated all open positions and paid the fees for transacting and crossing the spread.

volume

The total value of assets traded for all of an algorithm's transactions.

win rate

The proportion of trades that were profitable after transaction fees.

Initialization

Introduction

The Initialize initialize method is the entry point of your algorithm where you define a series of settings, including security subscriptions, starting cash balances, and warm-up periods. LEAN only calls the Initialize initialize method one time, at the start of your algorithm.

Set Dates

To set the date range of backtests, call the SetStartDate set_start_date and SetEndDate set_end_date methods. The dates you provide are based in the algorithm time zone. By default, the end date is yesterday, one millisecond before midnight. In live trading, LEAN ignores the start and end dates.

SetStartDate(2013, 1, 5);                  // Set start date to January 5, 2013
SetEndDate(2015, 1, 5);                    // Set end date to January 5, 2015
SetEndDate(DateTime.Now.Date.AddDays(-7)); // Set end date to last week

self.set_start_date(2013, 1, 5)                  # Set start date to January 5, 2013
self.set_end_date(2015, 1, 5)                    # Set end date to January 5, 2015
self.set_end_date(datetime.now() - timedelta(7)) # Set end date to last week

Set Account Currency

The algorithm equity curve, benchmark, and performance statistics are denominated in the account currency. To set the account currency and your starting cash, call the SetAccountCurrency set_account_currency method. By default, the account currency is USD and your starting cash is $100,000. If you call the SetAccountCurrency set_account_currency method, you must call it before you call the SetCash set_cash method or add data . If you call the SetAccountCurrency set_account_currency method more than once, only the first call takes effect.

SetAccountCurrency("BTC"); // Set account currency to Bitcoin and its quantity to 100,000 BTC
SetAccountCurrency("INR"); // Set account currency to Indian Rupees and its quantity to 100,000 INR
SetAccountCurrency("BTC", 10);  // Set account currency to Bitcoin and its quantity to 10 BTC

self.set_account_currency("BTC") # Set account currency to Bitcoin and its quantity to 100,000 BTC
self.set_account_currency("INR") # Set account currency to Indian Rupees and its quantity to 100,000 INR
self.set_account_currency("BTC", 10);  // Set account currency to Bitcoin and its quantity to 10 BTC

Set Cash

To set your starting cash in backtests, call the SetCash set_cash method. By default, your starting cash is $100,000 USD. In live trading, LEAN ignores the SetCash set_cash method and uses the cash balances in your brokerage account instead.

SetCash(100000);       // Set the quantity of the account currency to 100,000
SetCash("BTC", 10);    // Set the Bitcoin quantity to 10
SetCash("EUR", 10000); // Set the EUR quantity to 10,000

self.set_cash(100000)       # Set the quantity of the account currency to 100,000
self.set_cash("BTC", 10)    # Set the Bitcoin quantity to 10
self.set_cash("EUR", 10000) # Set the EUR quantity to 10,000

Set Brokerage and Cash Model

We model your algorithm with margin modeling by default, but you can select a cash account type. Cash accounts don't allow leveraged trading, whereas Margin accounts can support leverage on your account value. To set your brokerage and account type, call the SetBrokerageModel set_brokerage_model method. For more information about each brokerage and the account types they support, see the brokerage integration documentation. For more information about the reality models that the brokerage models set, see Supported Models .

SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);

self.set_brokerage_model(BrokerageName.INTERACTIVE_BROKERS_BROKERAGE, AccountType.CASH)

The AccountType enumeration has the following members:

Set Universe Settings

The universe settings of your algorithm configure some properties of the universe constituents. The following table describes the properties of the UniverseSettings object:

To set the UniverseSettings universe_settings , update the preceding properties in the Initialize initialize method before you add the universe. These settings are globals, so they apply to all universes you create.

// Request second resolution data. This will be slow!
UniverseSettings.Resolution = Resolution.Second;
AddUniverse(Universe.DollarVolume.Top(50));

# Request second resolution data. This will be slow!
self.universe_settings.resolution = Resolution.SECOND
self.add_universe(self.universe.dollar_volume.top(50))

For more information about universe settings, see the related documentation for classic and framework algorithms.

Set Security Initializer

Instead of configuring global universe settings, you can individually configure the settings of each security in the universe with a security initializer. Security initializers let you apply any security-level reality model or special data requests on a per-security basis. To set the security initializer, in the Initialize initialize method, call the SetSecurityInitializer set_security_initializer method and then define the security initializer.

//In Initialize
SetSecurityInitializer(CustomSecurityInitializer);

private void CustomSecurityInitializer(Security security)
{
    // Disable trading fees
    security.SetFeeModel(new ConstantFeeModel(0, "USD"));
}

#In Initialize
self.set_security_initializer(self._custom_security_initializer)

def _custom_security_initializer(self, security: Security) -> None:
    # Disable trading fees
    security.set_fee_model(ConstantFeeModel(0, "USD"))

For simple requests, you can use the functional implementation of the security initializer. This style lets you configure the security object with one line of code.

SetSecurityInitializer(security => security.SetFeeModel(new ConstantFeeModel(0, "USD")));

self.set_security_initializer(lambda security: security.set_fee_model(ConstantFeeModel(0, "USD")))

In some cases, you may want to trade a security in the same time loop that you create the security subscription. To avoid errors, use a security initializer to set the market price of each security to the last known price. The GetLastKnownPrices get_last_known_prices method seeds the security price by gathering the security data over the last 3 days. If there is no data during this period, the security price remains at 0.

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(security => seeder.SeedSecurity(security));

seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(lambda security: seeder.seed_security(security))

If you call the SetSecurityInitializer set_security_initializer method, it overwrites the default security initializer. The default security initializer uses the security-level reality models of the brokerage model to set the following reality models of each security:

• Fill
• Slippage
• Fee
• Buying Power
• Settlement
• Short availability
• Margin Interest Rate

The default security initializer also sets the leverage of each security and intializes each security with a seeder function. To extend upon the default security initializer instead of overwriting it, create a custom BrokerageModelSecurityInitializer .

// In Initialize
SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

// Outside of the algorithm class
class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition
        // This method sets the reality models of each security using the default reality models of the brokerage model
        base.Initialize(security);

        // Next, overwrite some of the reality models        
        security.SetFeeModel(new ConstantFeeModel(0, "USD"));    
    }
}

# In Initialize
self.set_security_initializer(MySecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)
    
    def initialize(self, security: Security) -> None:
        # First, call the superclass definition
        # This method sets the reality models of each security using the default reality models of the brokerage model
        super().initialize(security)

        # Next, overwrite some of the reality models        
        security.set_fee_model(ConstantFeeModel(0, "USD"))

To set a seeder function without overwriting the reality models of the brokerage, use the standard BrokerageModelSecurityInitializer .

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, seeder));

seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, seeder))

Add Data

You can subscribe to asset, fundamental, alternative, and custom data. The Dataset Market provides 400TB of data that you can easily import into your algorithms.

Asset Data

To subscribe to asset data, call one of the asset subscription methods like AddEquity add_equity or AddForex add_forex . Each asset class has its own method to create subscriptions. For more information about how to create subscriptions for each asset class, see Asset Classes .

AddEquity("AAPL"); // Add Apple 1 minute bars (minute by default)
AddForex("EURUSD", Resolution.Second); // Add EURUSD 1 second bars

self.add_equity("SPY")  # Add Apple 1 minute bars (minute by default)
self.add_forex("EURUSD", Resolution.SECOND) # Add EURUSD 1 second bars

In live trading, you define the securities you want, but LEAN also gets the securities in your live portfolio and sets their resolution to the lowest resolution of the subscriptions you made. For example, if you create subscriptions in your algorithm for securities with Second, Minute, and Hour resolutions, the assets in your live portfolio are given a resolution of Second.

Alternative Data

To add alternative datasets to your algorithms, call the AddData add_data method. For full examples, in the Datasets chapter, select a dataset and see the Requesting Data section.

Custom Data

To add custom data to your algorithms, call the AddData add_data method. For more information about custom data, see Importing Data .

Limitations

There is no official limit to how much data you can add to your algorithms, but there are practical resource limitations. Each security subscription requires about 5MB of RAM, so larger machines let you run algorithms with bigger universes. For more information about our cloud nodes, see Resources .

Set Indicators and Consolidators

You can create and warm-up indicators in the Initialize initialize method.

private Symbol _symbol;
private SimpleMovingAverage _sma;

_symbol = AddEquity("SPY").Symbol;
_sma = SMA(_symbol, 20);
WarmUpIndicator(_symbol, _sma);

self._symbol = self.add_equity("SPY").symbol
self._sma = self.sma(self._symbol, 20)
self.warm_up_indicator(self._symbol, self._sma)

Set Algorithm Settings

The following table describes the AlgorithmSettings properties:

To change the Settings settings , update some of the preceding properties.

Settings.RebalancePortfolioOnSecurityChanges = false;
Settings.TradingDaysPerYear = 365;

self.settings.rebalance_portfolio_on_security_changes = False
self.settings.trading_days_per_year = 365

To successfully update the FreePortfolioValue free_portfolio_value , you must update it after the Initialize initialize method.

Set Benchmark

The benchmark performance is input to calculate several statistics on your algorithm, including alpha and beta . To set a benchmark for your algorithm, call the SetBenchmark set_benchmark method. You can set the benchmark to a security, a constant value, or a value from a custom data source . If you don't set a brokerage model , the default benchmark is SPY. If you set a brokerage model, the model defines the default benchmark.

// Set the benchmark to IBM
SetBenchmark("IBM");

// Set the benchmark to a constant value of 0
SetBenchmark(x => 0);

// Set the benchmark to a value from a custom data source
var symbol = AddData<CustomData>("CustomData", Resolution.Hour).Symbol;
SetBenchmark(symbol);

# Set the benchmark to IBM
self.set_benchmark("IBM")

# Set the benchmark to a constant value of 0
self.set_benchmark(lambda x: 0)

# Set the benchmark to a value from a custom data source
symbol = self.add_data(CustomData, "CustomData", Resolution.HOUR).symbol
self.set_benchmark(symbol)

If you pass a ticker to the SetBenchmark set_benchmark method, LEAN checks if you have a subscription for it. If you have a subscription for it, LEAN uses the security subscription. If you don't have a subscription for it, LEAN creates a US Equity subscription with the ticker. Since the ticker you pass may not reference a US Equity, we recommend you subscribe to the benchmark security before you call the SetBenchmark set_benchmark method.

Set Time Zone

LEAN supports international trading across multiple time zones and markets, so it needs a reference time zone for the algorithm to set the Time time . The default time zone is Eastern Time (ET), which is UTC-4 in summer and UTC-5 in winter. To set a different time zone, call the SetTimeZone set_time_zone method. This method accepts either a string following the IANA Time Zone database convention or a NodaTime .DateTimeZone object. If you pass a string, the method converts it to a NodaTime.DateTimeZone object. The TimeZones class provides the following helper attributes to create NodaTime.DateTimeZone objects:

SetTimeZone("Europe/London");
SetTimeZone(NodaTime.DateTimeZone.Utc);
SetTimeZone(TimeZones.Chicago);

self.set_time_zone("Europe/London")
self.set_time_zone(TimeZones.CHICAGO)

The algorithm time zone may be different from the data time zone . If the time zones are different, it might appear like there is a lag between the algorithm time and the first bar of a history request, but this is just the difference in time zone. All the data is internally synchronized in Coordinated Universal Time (UTC) and arrives in the same Slice object. A slice is a sliver of time with all the data available for this moment.

To keep trades easy to compare between asset classes, we mark all orders in UTC time.

Set Warm Up Period

You may need some historical data at the start of your algorithm to prime technical indicators or populate historical data arrays. The warm-up period pumps data into your algorithm from before the start date. To set a warm-up period, call the SetWarmUp set_warm_up method. The warm-up feature uses the subscriptions you add in Initialize initialize to gather the historical data that warms up the algorithm. If you don't create security subscriptions in the Initialize initialize method, the warm-up won't occur.

// Wind time back 7 days from the start date
SetWarmUp(TimeSpan.FromDays(7));

// Feed in 100 trading days worth of data before the start date
SetWarmUp(100, Resolution.Daily);

// If you don't provide a resolution argument, it uses the lowest resolution in your subscriptions
SetWarmUp(100);

# Wind time back 7 days from the start date
self.set_warm_up(timedelta(7))

# Feed in 100 trading days worth of data before the start date
self.set_warm_up(100, Resolution.DAILY)

# If you don't provide a resolution argument, it uses the lowest resolution in your subscriptions
self.set_warm_up(100)

Set Name and Tags

You can categorize your backtest with a name and tags. To set the algorithm Name name , call the SetName set_name method.

SetName("Backtest Name");

self.set_name("Backtest Name")

The SetName set_name method overwrites the names of backtests of an optimization , which contains the parameter values. To keep these values, create a name that includes them.

var fastPeriod = GetParameter("fast_period", 100);
var midPeriod = GetParameter("mid_period", 200);
var slowPeriod = GetParameter("slow_period", 300);
SetName($"Backtest Name ({fastPeriod},{midPeriod},{slowPeriod})");

fast_period = self.get_parameter("fast_period", 100);
mid_period = self.get_parameter("mid_period", 200);
slow_period = self.get_parameter("slow_period", 300);
self.set_name(f"Backtest Name ({fast_period},{mid_period},{slow_period})");

To add tags to you algorithm, call the AddTag add_tag method.

AddTag("Long Only");
AddTag("Momentum");     
    

self.add_tag("Long Only")
self.add_tag("Momentum")

Your algorithm can add 20 tags. The name and each tag can have up to 200 characters or else they are truncated.

Post Initialization

After the Initialize initialize method, the PostInitialize post_initialize method performs post-initialization routines, so don't override it. To be notified when the algorithm is ready to begin trading, define an OnWarmupFinished on_warmup_finished method. This method executes even if you don't set a warm-up period.

public override void OnWarmupFinished()
{
    Log("Algorithm Ready");
}

def on_warmup_finished(self) -> None:
    self.log("Algorithm Ready")

Examples

Securities

Securities > Key Concepts

Introduction

A security is an individual financial asset that you might trade on an exchange. LEAN models these unique assets with a Security object, which the AddEquity add_equity , AddCrypto add_crypto , and similar methods return. The Securities securities property of the QCAlgorithm class is a dictionary where the keys are Symbol objects and the values are Security objects. The Securities securities dictionary contains all of the securities that have been in the algorithm during its lifetime.

Quote Currency

The quote currency is the currency you must give the seller to buy an asset. For currency trades, the quote currency is the currency ticker on the right side of the currency pair. For other types of assets, the quote currency is usually USD, but the quote currency for India Equities is INR. To get the quote currency of a Security , use the QuoteCurrency quote_currency property.

var aaplQuoteCurrency = Securities["AAPL"].QuoteCurrency; // USD
var btcusdtQuoteCurrency = Securities["BTCUSDT"].QuoteCurrency; // USDT

aapl_quote_currency = self.securities["AAPL"].quote_currency # USD
btcusdt_quote_currency = self.securities["BTCUSDT"].quote_currency # USDT

The QuoteCurrency quote_currency is a Cash object, which have the following properties:

You can use the ConversionRate conversion_rate property to calculate the value of the minimum price movement in the account currency

var cfd = Securities["SG30SGD"];
var quoteCurrency = cfd.QuoteCurrency; // SGD
var contractMutiplier = cfd.SymbolProperties.ContractMultiplier;
var minimumPriceVariation = cfd.SymbolProperties.MinimumPriceVariation;

// Value of a pip in account currency
var pip = minimumPriceVariation * contractMutiplier * quoteCurrency.ConversionRate;

cfd = self.securities["SG30SGD"]
quote_currency = cfd.quote_currency # SGD
contract_mutiplier = cfd.symbol_properties.contract_multiplier
minimum_price_variation = cfd.symbol_properties.minimum_price_variation

# Value of a pip in account currency
pip = minimum_price_variation * contract_mutiplier * quote_currency.conversion_rate

Security Listing

The Exchange exchange property of a Security object contains information about the exchange that lists the security.

var exchange = Securities["SPY"].Exchange;

exchange = self.securities["SPY"].exchange

Security Market

The Market enumeration has the following members:

LEAN groups all of the US Equity exchanges under Market.USA . In live mode, the brokerage routes the orders to the exchange that provides the best price.

Active Securities

The ActiveSecurities active_securities property of the algorithm class contains all of the assets currently in your algorithm. It is a dictionary where the key is a Symbol and the value is a Security . When you remove an asset from a universe, LEAN usually removes the security from the ActiveSecurities active_securities collection and removes the security subscription. However, it won't remove the security in any of the following situations:

• You own the security.
• You have an open order for the security.
• The security wasn't in the universe long enough to meet the MinimumTimeInUniverse minimum_time_in_universe setting.

When LEAN removes the security, the Security object remains in the Securities securities collection for record-keeping purposes, like tracking fees and trading volume.

To improve iteration speed, LEAN removes delisted securities from the Securities securities primary collection. To access all the securities, iterate the Securities.Total securities.total property.

foreach (var security in Securities.Total)
{ 

}

// Exclude delisted securities
foreach (var security in Securities.Values)
{ 

}

for security in self.securities.total:
    pass

# Exclude delisted securities
for security in self.securities.values():
    pass

To get only the assets that are currently in the universe, see Selected Securities .

Tradable Status

The IsTradable is_tradable property shows whether you can trade a security. The property value is true when the security is in the universe, even if the data starts at a later day. Indices, canonical Option securities, and continuous Futures contracts are not tradable. In live mode, custom data objects are also not tradable, even if the custom data represents a tradable asset.

var tradable = Securities["SPY"].IsTradable;

tradable = self.securities["SPY"].is_tradable

Fundamental Data

To get fundamental data for a Security in your algorithm, use its Fundamentals fundamentals property. The fundamental data represent the company's fundamentals for the current algorithm time.

var fundamentals = Securities[_symbol].Fundamentals;

fundamentals = self.securities[self._symbol].fundamentals

Some assets don't have fundamentals (for example, ETFs) and the Morningstar dataset doesn't provide fundamentals for all US Equities. To check if fundamental data is available for an asset, use the HasFundamentalData has_fundamental_data property.

var hasFundamentalData = Securities[_symbol].Fundamentals.HasFundamentalData;

has_fundamental_data = self.securities[self._symbol].fundamentals.has_fundamental_data

For more information about fundamental data, see Corporate Fundamentals .

Linked Custom Data

Linked custom data is custom data that's linked to individual assets. In contrast, unlinked data is not linked to specific assets. An example of an unlinked dataset is the US Regulatory Alerts dataset. LEAN passes custom data objects to the OnData on_data method. For more information about custom data, see Custom Securities .

Security Types

LEAN uses the SecurityType enumeration as a synonym for asset classes. The SecurityType enumeration has the following members:

The Base type is for non-financial assets like custom and alternative data objects.

Securities > Properties

Introduction

Security objects contain the models and properties of an asset.

Security Properties

Security objects have the following properties:

Custom Security Properties

You can add properties attributes to the Security object. For example, you can add an exponential moving average .

dynamic equity = AddEquity("SPY");
equity.ema = EMA(equity.Symbol, 10, Resolution.Daily);

equity = self.add_equity("SPY")
equity.ema = self.ema(equity.symbol, 10, Resolution.DAILY)

This feature is helpful because you can get the Security object from the Securities securities object.

var ema = (Securities["SPY"] as dynamic).ema.Current.Value;

ema = self.securities["SPY"].ema.current.value

Reality Models

Security objects contain references to the security level reality models . To customize the behavior of each security, configure its reality models.

Symbol Properties

The SymbolProperties symbol_properties property of a Security contains properties for a specific security. SymbolProperties objects have the following properties:

To create a SymbolProperties object, call the constructor.

var symbolProperties = new SymbolProperties(description, quoteCurrency, contractMultiplier, minimumPriceVariation, lotSize, marketTicker);

symbol_properties = SymbolProperties(description, quoteCurrency, contractMultiplier, minimumPriceVariation, lotSize, marketTicker)

The following table describes the arguments of the SymbolProperties constructor:

Securities > Exchange

Introduction

The Exchange property of a Security object contains information about the exchange that lists the security.

Properties

The Exchange exchange property of a Security object returns an SecurityExchange object, which has the following attributes:

Hours

To get the exchange hours, use the Exchange.Hours exchange.hours property on a Security object.

var securityExchangeHours = Securities["SPY"].Exchange.Hours;

security_exchange_hours = self.securities["SPY"].exchange.hours

The preceding code snippet returns a SecurityExchangeHours object, which has the following attributes:

To check if the exchange is open at a specific time, call the IsOpen is_open method.

// Check if the exchange is open at a specific time
var isOpenNow = securityExchangeHours.IsOpen(Time, extendedMarketHours: false);

// Check if the exchange is open at any point in time over a specific interval
var isOpen = securityExchangeHours.IsOpen(Time, Time.AddDays(1), extendedMarketHours: false);

# Check if the exchange is open at a specific time
is_open_now = security_exchange_hours.is_open(self.time, extended_market_hours=False)

# Check if the exchange is open at any point in time over a specific interval
is_open = security_exchange_hours.is_open(self.time, self.time + timedelta(days=1), extended_market_hours=False)

To check if the exchange is open on a specific date, call the IsDateOpen is_date_open method.

var isOpen = securityExchangeHours.IsDateOpen(Time);

is_open = security_exchange_hours.is_date_open(self.time)

To get the next market open time, call the GetNextMarketOpen get_next_market_open method.

var marketOpenTime = securityExchangeHours.GetNextMarketOpen(Time, extendedMarketHours: false);

market_open_time = security_exchange_hours.get_next_market_open(self.time, extended_market_hours=False)

To get the next market close time, call the GetNextMarketClose get_next_market_close method.

var marketCloseTime = securityExchangeHours.GetNextMarketClose(Time, extendedMarketHours: false);

market_close_time = security_exchange_hours.get_next_market_close(self.time, extended_market_hours=False)

To get the previous trading day, call the GetPreviousTradingDay get_previous_trading_day method.

var day = securityExchangeHours.GetPreviousTradingDay(Time);

day = security_exchange_hours.get_previous_trading_day(self.time)

To get the next trading day, call the GetNextTradingDay get_next_trading_day method.

var day = securityExchangeHours.GetNextTradingDay(Time);

day = security_exchange_hours.get_next_trading_day(self.time)

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours extended_market_hours argument when you create the security subscription.

AddEquity("SPY", extendedMarketHours: true);

self.add_equity("SPY", extended_market_hours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

24 Hour Markets

The Crypto market trades 24/7, but other asset classes only trade during part of the week. Each market has an official trading schedule, but it can be impacted by daylight savings, holidays, and trading halts.

Securities > Requesting Data

Introduction

If you create a data subscription, your algorithm receives data updates for that security or custom data source.

Characteristics

We thoroughly vet datasets before we add them to the Data Market. The datasets in the Data Market are well-defined with robust ticker and Symbol links to ensure tickers are properly tracked through time. The datasets are consistently delivered on time and most of them are ready for live trading. All the datasets have at least one year of historical data and are free of survivorship bias.

Resolutions

Resolution is the duration of time that's used to sample a data source. The Resolution enumeration has the following members:

The default resolution for market data is Minute MINUTE . To set the resolution for a security, pass the resolution argument when you create the security subscription.

AddEquity("SPY", Resolution.Daily);

self.add_equity("SPY", Resolution.DAILY)

To set the resolution for all securities, set the Resolution universe setting before you create security subscriptions.

UniverseSettings.Resolution = Resolution.Daily;

self.universe_settings.resolution = Resolution.DAILY

To see which resolutions of data are available for a dataset, see the dataset listing in the Data Market . To create custom resolution periods, see Consolidating Data .

Data density describes the frequency of entries in a dataset. Datasets at the tick resolution have dense data density. All other resolutions usually have regular data density. If a non-tick resolution dataset doesn't have an entry at each sampling, it has sparse density.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

AddEquity("SPY", fillForward: false);

self.add_equity("SPY", fill_forward=False)

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours extended_market_hours argument when you create the security subscription.

AddEquity("SPY", extendedMarketHours: true);

self.add_equity("SPY", extended_market_hours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

Remove Subscriptions

To remove a security subscription, call the RemoveSecurity remove_security method.

RemoveSecurity(_symbol);

self.remove_security(self._symbol)

The RemoveSecurity remove_security method cancels your open orders for the security and liquidates your holdings.

Markets

The datasets integrated into the Dataset Market cover many markets. The Market enumeration has the following members:

LEAN can usually determine the correct market based on the ticker you provide when you create the security subscription. To manually set the market for a security, pass a market argument when you create the security subscription.

AddEquity("SPY", market: Market.USA);

self.add_equity("SPY", market=Market.USA)

Securities > Handling Data

Introduction

LEAN packages the data for your subscriptions in a Slice object and passes it to the OnData on_data method of your algorithm. To avoid look-ahead bias , LEAN only provides the data that's available at the current time in your algorithm. This processing style ensures that your algorithm backtests in the same manner that it trades live. Your algorithm uses the data to make trading decisions and LEAN uses the data to update your positions, track your portfolio value, and simulate orders.

Security Cache

To get the most recent data for a security, call the GetLastData get_last_data method on the Security object.

var data = Securities["SPY"].GetLastData();

data = self.securities["SPY"].get_last_data()

Timeslice

The Slice that LEAN passes to the OnData on_data method represents all of the data for your subscriptions at a single point in time. The Slice object contains data like Tick TICK objects, TradeBar objects, QuoteBar objects, corporate actions , and chains for Option and Future contracts. You can use the data in the Slice to make trading decisions.

To access data in the Slice , index it with the security Symbol . If you use the security ticker instead of the Symbol , LEAN automatically finds the Symbol .

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var myData = slice[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    if slice.contains_key(self._symbol):
        my_data = slice[self._symbol]

The following table shows the Slice property to index based on the data format you want:

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var bar = slice.Bars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    if slice.contains_key(self._symbol):
        bar = slice.bars[self._symbol]

If you just index the Slice instead of the preceding properties, it returns the correct object. If your data subscription provides QuoteBar objects and you index the Slice with the security Symbol , it returns the QuoteBar .

Slice objects have the following properties:

For more information about the Slice class, see Timeslices .

Corporate Actions

The Slice that LEAN passes to the OnData on_data method may contain corporate action data for the Equities in your algorithm. Instead of adding logic to your OnData on_data defintion to respond to corporate actions (for example, resetting indicators ), you can isolate the logic in one of the following event handlers.

Splits

The OnSplits on_splits event handler provides information on stock splits.

public override void OnSplits(Splits splits)
{
    foreach (var kvp in splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

def on_splits(self, splits: Splits) -> None:
    for symbol, split in splits.items():
        pass

Dividends

The OnDividends on_dividends event handler provides information on dividend payments.

public override void OnDividends(Dividends dividends)
{
    foreach (var kvp in dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

def on_dividends(self, dividends: Dividends) -> None:
    for symbol, dividend in dividends.items():
        pass

Symbol Changes

The OnSymbolChangedEvents on_symbol_changed_events event handler provides information on ticker changes.

public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    foreach (var kvp in symbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    for symbol, symbol_changed_event in symbol_changed_events.items():
        pass

Delistings

The OnDelistings on_delistings event handler provides information on asset delistings.

public override void OnDelistings(Delistings delistings)
{
    foreach (var kvp in delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

def on_delistings(self, delistings: Delistings) -> None:
    for symbol, delisting in delistings.items():
        pass

Securities > Filtering Data

Introduction

Unfiltered raw data can be faulty for a number of reasons, including invalid data entry. Moreover, high-frequency traders can deploy bait-and-switch strategies by submitting bait orders to deceive other market participants, making raw data noisy and untradeable. To avoid messing up with our trading logic and model training, you can filter out suspicious raw data with a data filter.

Set Models

To set a data filter for a security, call the SetDataFilter set_data_filter property on the Security object.

// In Initialize
var spy = AddEquity("SPY");
spy.SetDataFilter(new SecurityDataFilter());

# In Initialize
spy = self.add_equity("SPY")
spy.set_data_filter(SecurityDataFilter())

You can also set the data filter model in a security initializer . If your algorithm has a universe, use the security initializer technique. In order to initialize single security subscriptions with the security initializer, call SetSecurityInitializer set_security_initializer before you create the subscriptions.

// In Initialize
SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

// Outside of the algorithm class
class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition
        // This method sets the reality models of each security using the default reality models of the brokerage model
        base.Initialize(security);

        // Next, overwrite some of the reality models        
        security.SetDataFilter(new SecurityDataFilter());    
    }
}

# In Initialize
self.set_security_initializer(MySecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)
    
    def initialize(self, security: Security) -> None:
        # First, call the superclass definition
        # This method sets the reality models of each security using the default reality models of the brokerage model
        super().initialize(security)

        # Next, overwrite some of the reality models        
        security.set_data_filter(SecurityDataFilter())

Default Behavior

The following table shows the default data filter for each security type:

None of the preceding filters filter out any data.

Model Structure

Data filtering models should implement the ISecurityDataFilter interface. Extensions of the ISecurityDataFilter interface must implement the Filter method, which receives Security and BaseData objects and then returns a boolean object that represents if the data point should be filtered out.

Data filtering models must implement a filter method, which receives Security and BaseData objects and then returns a boolean object that represents if the data point should be filtered out.

public class MyDataFilter : ISecurityDataFilter
{
    public override bool Filter(Security vehicle, BaseData data)
    {
        return true;
    }
}

class MyDataFilter(SecurityDataFilter):
    def filter(self, vehicle: Security, data: BaseData) -> bool:
        return True

Examples

Securities > Asset Classes

Securities > Asset Classes > US Equity

Securities > Asset Classes > US Equity > Requesting Data

Introduction

Request US Equity data in your algorithm to receive a feed of asset prices in the OnData on_data method. For more information about the specific dataset we use for backtests, see the US Equities dataset listing . To trade US Equities live, you can use the QuantConnect data provider or one of the brokerage data providers .

Create Subscriptions

To create an Equity subscription, in the Initialize initialize method, call the AddEquity add_equity method. The AddEquity add_equity method returns an Equity object, which contains a Symbol symbol property. Save a reference to the Symbol symbol so you can use it in OnData on_data to access the security data in the Slice .

_symbol = AddEquity("SPY").Symbol;

self._symbol = self.add_equity("SPY").symbol

The AddEquity add_equity method creates a subscription for a single Equity asset and adds it to your user-defined universe. To create a dynamic universe of Equities, add an Equity universe or an Equity Universe Selection model .

To view the supported assets in the US Equities dataset, see the Data Explorer .

Resolutions

The following table shows the available resolutions and data formats for Equity subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick TICK
Second SECOND
Minute MINUTE
Hour HOUR
Daily DAILY

The default resolution for Equity subscriptions is Resolution.Minute Resolution.MINUTE . To change the resolution, pass a resolution argument to the AddEquity add_equity method.

_symbol = AddEquity("SPY", Resolution.Daily).Symbol;

self._symbol = self.add_equity("SPY", Resolution.DAILY).symbol

To create custom resolution periods, see Consolidating Data .

Asset Primary Exchange

When a stock like Apple is listed, it’s listed on Nasdaq. The open auction tick on Nasdaq is the price that’s used as the official open of the day. NYSE, BATS, and other exchanges also have opening auctions, but the only official opening price for Apple is the opening auction on the exchange where it was listed.

Supported Markets

LEAN groups all of the US Equity exchanges under Market.USA . In live mode, the brokerage routes the orders to the exchange that provides the best price.

To set the market for a security, pass a market argument to the AddEquity add_equity method.

_symbol = AddEquity("SPY", market: Market.USA).Symbol;

self._symbol = self.add_equity("SPY", market=Market.USA).symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

AddEquity("SPY", fillForward: false);

self.add_equity("SPY", fill_forward=False)

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. In backtests, the default leverage for margin accounts is 2x leverage and leverage is not available for cash accounts. To change the amount of leverage you can use for a security, pass a leverage argument to the AddEquity add_equity method.

_symbol = AddEquity("SPY", leverage: 3).Symbol;

self._symbol = self.add_equity("SPY", leverage=3).symbol

In live trading, the brokerage determines how much leverage you may use. For more information about the leverage they provide, see Brokerages .

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours extended_market_hours argument when you create the security subscription.

AddEquity("SPY", extendedMarketHours: true);

self.add_equity("SPY", extended_market_hours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours .

Data Normalization

The data normalization mode defines how historical data is adjusted for corporate actions . The data normalization mode affects the data that LEAN passes to OnData on_data and the data from history requests . By default, LEAN adjusts US Equity data for splits and dividends to produce a smooth price curve, but the following data normalization modes are available for Equity subscriptions:

If you use Adjusted ADJUSTED , SplitAdjusted SPLIT_ADJUSTED , or TotalReturn TOTAL_RETURN , we use the entire split and dividend history to adjust historical prices. This process ensures you get the same adjusted prices, regardless of the backtest end date. The ScaledRaw SCALED_RAW data normalization is only for history requests . When you use ScaledRaw SCALED_RAW , we use the split and dividend history before the algorithm's current time to adjust historical prices. The ScaledRaw SCALED_RAW data normalization model enables you to warm up indicators with adjusted data when you subscribe to Raw RAW security data.

To set the data normalization mode for a security, pass a dataNormalizationMode data_normalization_mode argument to the AddEquity add_equity method.

_symbol = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self._symbol = self.add_equity("SPY", data_normalization_mode=DataNormalizationMode.RAW).symbol

Properties

The AddEquity add_equity method returns an Equity object, which have the following properties:

Securities > Asset Classes > US Equity > Handling Data

Introduction

LEAN passes the data you request to the OnData on_data method so you can make trading decisions. The default OnData on_data method accepts a Slice object, but you can define additional OnData on_data methods that accept different data types. For example, if you define an OnData on_data method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData on_data method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData on_data method, use the CurrentSlice current_slice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol symbol , but we recommend you use the Symbol symbol .

To view the resolutions that are available for US Equity data, see Resolutions .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars bars property of the Slice with the security Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    trade_bar = slice.bars.get(self._symbol)   # None if not found

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        close_price = trade_bar.close

We adjust the daily open and close price of bars to reflect the official auction prices .

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open open , High high , Low low , and Close close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open open , High high , Low low , and Close close properties of the QuoteBar copy the values of either the Bid bid or Ask ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the security Symbol symbol . If the security doesn't actively get quotes or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    quote_bar = slice.quote_bars.get(self._symbol)   # None if not found

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.quote_bars.items():
        ask_price = quote_bar.ask.close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the security. A quote tick is an offer to buy or sell the security at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity quantity and Price price properties, but they have a zero value for the BidPrice bid_price , BidSize bid_size , AskPrice ask_price , and AskSize ask_size properties. Quote ticks have non-zero values for BidPrice bid_price and BidSize bid_size properties or have non-zero values for AskPrice ask_price and AskSize ask_size properties. To check if a tick is a trade or a quote, use the TickType ticktype property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    ticks = slice.ticks.get(self._symbol, [])   # Empty if not found
    for tick in ticks:
        price = tick.price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            price = tick.price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

If we detect a tick that may be suspicious , we set its Suspicious suspicious flag to true.

Other Data Formats

For more information about data formats available for US Equities, see Corporate Actions .

Securities > Asset Classes > US Equity > Corporate Actions

Introduction

US Equity subscriptions provide notifications for splits, dividends, symbol changes, and delistings.

Splits

When a company does a stock split, the number of shares each shareholder owns increases and the price of each share decreases. When a company does a reverse stock split, the number of shares each shareholder owns decreases and the price of each share increases. A company may perform a stock split or a reverse stock split to adjust the price of their stock so that more investors trade it and the liquidity increases.

When a stock split or reverse stock split occurs for an Equity in your algorithm, LEAN sends a Split object to the OnData on_data method. Split objects have the following properties:

You receive Split objects when a split is in the near future and when it occurs. To know if the split occurs in the near future or now, check the Type type property.

If you backtest without the Raw RAW data normalization mode , the splits are factored into the price and volume. If you backtest with the Raw RAW data normalization mode or trade live, when a split occurs, LEAN automatically adjusts your positions based on the SplitFactor split_factor . If the post-split quantity isn't a valid lot size , LEAN credits the remaining value to your cashbook in your account currency. If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when splits occur so that the data in your indicators account for the price adjustments that the splits cause.

To get the Split objects, index the Splits splits object with the security Symbol symbol . The Splits splits object may not contain data for your Symbol . To avoid issues, check if the Splits splits object contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Splits.ContainsKey(_symbol))
    {
        var split = slice.Splits[_symbol];
    }
}

public override void OnSplits(Splits splits)
{
    if (splits.ContainsKey(_symbol))
    {
        var split = splits[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    split = slice.splits.get(self._symbol)
    if split:
        pass


def on_splits(self, splits: Splits) -> None:
    split = splits.get(self._symbol)
    if split:
        pass

You can also iterate through the Splits splits dictionary. The keys of the dictionary are the Symbol objects and the values are the Split objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

public override void OnSplits(Splits splits)
{
    foreach (var kvp in splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, split in slice.splits.items():
        pass

def on_splits(self, splits: Splits) -> None:
    for symbol, split in splits.items():
        pass

LEAN stores the data for stock splits in factor files. To view some example factor files, see the LEAN GitHub repository . In backtests, your algorithm receives Split objects at midnight. In live trading, your algorithm receives Split objects when the factor files are ready.

If you hold an Option contract for an underlying Equity when a split occurs, LEAN closes your Option contract position.

If a split event occurs before your order is filled, the unfilled portion of the order is adjusted automatically, where its quantity is multiplied by the split factor and the limit/stop/trigger price (if any) is divided by the split factor.

Dividends

A dividend is a payment that a company gives to shareholders to distribute profits. When a dividend payment occurs for an Equity in your algorithm, LEAN sends a Dividend object to the OnData on_data method. Dividend objects have the following properties:

If you backtest with the Adjusted ADJUSTED or TotalReturn TOTAL_RETURN data normalization mode, the dividends are factored into the price. If you backtest with the other data normalization modes or trade live, when a dividend payment occurs, LEAN automatically adds the payment amount to your cashbook. If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when dividend payments occur so that the data in your indicators account for the price adjustments that the dividend causes.

To get the Dividend objects, index the Dividends dividends object with the security Symbol symbol . The Dividends dividends object may not contain data for your Symbol symbol . To avoid issues, check if the Dividends dividends object contains data for your security before you index it with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Dividends.ContainsKey(_symbol))
    {
        var dividend = slice.Dividends[_symbol];
    }
}

public override void OnDividends(Dividends dividends)
{
    if (dividends.ContainsKey(_symbol))
    {
        var dividend = dividends[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    dividend = slice.dividends.get(self._symbol)
    if dividend:
        pass

def on_dividends(self, dividends: Dividends) -> None:
    dividend = dividends.get(self._symbol)
    if dividend:
        pass

You can also iterate through the Dividends dividends dictionary. The keys of the dictionary are the Symbol objects and the values are the Dividend objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

public override void OnDividends(Dividends dividends)
{
    foreach (var kvp in dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, dividend in slice.dividends.items():
        pass

def on_dividends(self, dividends: Dividends) -> None:
    for symbol, dividend in dividends.items():
        pass

For a full example, see the DividendAlgorithm DividendAlgorithm in the LEAN GitHub repository.

Symbol Changes

The benefit of the Symbol class is that it always maps to the same security, regardless of their trading ticker. When a company changes its trading ticker, LEAN sends a SymbolChangedEvent to the OnData on_data method. SymbolChangedEvent objects have the following properties:

To get the SymbolChangedEvent objects, index the SymbolChangedEvents symbol_changed_events object with the security Symbol symbol . The SymbolChangedEvents symbol_changed_events object may not contain data for your Symbol symbol . To avoid issues, check if the SymbolChangedEvents symbol_changed_events object contains data for your security before you index it with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.SymbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = slice.SymbolChangedEvents[_symbol];
    }
}

public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    if (symbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = symbolChangedEvents[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    symbol_changed_event = slice.symbol_changed_events.get(self._symbol)
    if symbol_changed_event:
        pass

def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    symbol_changed_event = symbol_changed_events.get(self._symbol)
    if symbol_changed_event:
        pass

You can also iterate through the SymbolChangedEvents symbol_changed_events dictionary. The keys of the dictionary are the Symbol objects and the values are the SymbolChangedEvent objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.SymbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    foreach (var kvp in symbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, symbol_changed_event in slice.symbol_changed_events.items():
        pass


def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    for symbol, symbol_changed_event in symbol_changed_events.items():
        pass

If you have an open order for a security when they change their ticker, LEAN cancels your order. To keep your order, in the OnOrderEvent on_order_event method, get the quantity and Symbol of the cancelled order and submit a new order.

public override void OnOrderEvent(OrderEvent orderEvent)
{
    if (orderEvent.Status == OrderStatus.Canceled)
    {
        var ticket = Transactions.GetOrderTicket(orderEvent.OrderId);
        if (ticket.Tag.Contains("symbol changed event"))
        {
            Transactions.AddOrder(ticket.SubmitRequest);
        }
    } 
}

def on_order_event(self, order_event: OrderEvent) -> None:
    if order_event.status == OrderStatus.CANCELED:
        ticket = self.transactions.get_order_ticket(order_event.order_id)
        if "symbol changed event" in ticket.tag:
            self.transactions.add_order(ticket.submit_request)

LEAN stores the data for ticker changes in map files. To view some example map files, see the LEAN GitHub repository .

Delistings

When a company is delisting from an exchange, LEAN sends a Delisting object to the OnData on_data method. Delisting objects have the following properties:

You receive Delisting objects when a delisting is in the near future and when it occurs. To know if the delisting occurs in the near future or now, check the Type property.

To get the Delisting objects, index the Delistings delistings object with the security Symbol symbol . The Delistings delistings objects may not contain data for your Symbol symbol . To avoid issues, check if the Delistings delistings object contains data for your security before you index it with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Delistings.ContainsKey(_symbol))
    {
        var delisting = slice.Delistings[_symbol];
    }
}

public override void OnDelistings(Delistings delistings)
{
    if (delistings.ContainsKey(_symbol))
    {
        var delisting = delistings[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    delisting = slice.delistings.get(self._symbol)
    if delisting:
        pass

def on_delistings(self, delistings: Delistings) -> None:
    delisting = delistings.get(self._symbol)
    if delisting:
        pass

You can also iterate through the Delistings delistings dictionary. The keys of the dictionary are the Symbol objects and the values are the Delisting objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

public override void OnDelistings(Delistings delistings)
{
    foreach (var kvp in delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, delisting in slice.Delistings.items():
        pass

def on_delistings(self, delistings: Delistings) -> None:
    for symbol, delisting in delistings.items():
        pass

The delist warning occurs on the final trading day of the stock to give you time to gracefully exit out of positions before LEAN automatically liquidates them.

if (delisting.Type == DelistingType.Warning)
{
    // Liquidate with MarketOnOpenOrder on delisting warning
    var quantity = Portfolio[symbol].Quantity;
    if (quantity != 0)
    {
        MarketOnOpenOrder(symbol, -quantity);
    }
}

if delisting.type == DelistingType.WARNING:
    # Liquidate with MarketOnOpenOrder on delisting warning
    quantity = self.portfolio[symbol].quantity
    if quantity != 0:
        self.market_on_open_order(symbol, -quantity)

The OnSecuritiesChanged on_securities_changed event notifies the algorithm when delisted assets are removed from the universe.

To improve iteration speed, LEAN removes delisted securities from the Securities securities primary collection. To access all the securities, iterate the Securities.Total securities.total property.

foreach (var security in Securities.Total)
{ 

}

// Exclude delisted securities
foreach (var security in Securities.Values)
{ 

}

for security in self.securities.total:
    pass

# Exclude delisted securities
for security in self.securities.values():
    pass

For a full example, see the DelistingEventsAlgorithm DelistingEventsAlgorithm in the LEAN GitHub repository.

Live Trading Considerations

In backtesting, corporate actions occurs at midnight Eastern Time (ET). In live trading, the live data for corporate actions arrives at 6/7 AM ET, so that's when they occur.

Securities > Asset Classes > US Equity > Corporate Fundamentals

Introduction

Corporate fundamental data contains all the information on the underlying company of an Equity asset and the information in their financial statements. Since corporate data contains information not found in price and alternative data, adding corporate data to your trading strategies provides you with more information so you can make more informed trading decisions. Corporate fundamental data is available through the US Fundamental Data from Morningstar .

Direct Access

To get fundamental data for Equities in your algorithm, use the Fundamentals fundamentals property of the Equity objects. The fundamental data represent the company's fundamentals for the current algorithm time.

var fundamentals = Securities[_symbol].Fundamentals;

fundamentals = self.securities[self._symbol].fundamentals

To get fundamental data for Equities, regardless of whether or not you have subscribed to them in your algorithm, call the Fundamentals fundamentals method. If you pass one Symbol , the method returns a Fundamental object. If you pass a list of Symbol objects, the method returns a list of Fundamental objects. The fundamental data represents the corporate fundamentals for the current algorithm time.

// Single asset 
var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);
var ibmFundamental = Fundamentals(ibm);

// Multiple assets
var nb = QuantConnect.Symbol.Create("NB", SecurityType.Equity, Market.USA);
var fundamentals = Fundamentals(new List<Symbol>{ nb, ibm }).ToList();

# Single asset
ibm = QuantConnect.symbol.create("IBM", SecurityType.EQUITY, Market.USA)
ibm_fundamental = self.fundamentals(ibm)

# Multiple assets
nb = QuantConnect.symbol.create("NB", SecurityType.EQUITY, Market.USA)
fundamentals = self.fundamentals([ nb, ibm ])

Data Availability

Some assets don't have fundamentals (for example, ETFs) and the Morningstar dataset doesn't provide fundamentals for all US Equities. To check if fundamental data is available for an asset, use the HasFundamentalData has_fundamental_data property.

var hasFundamentalData = Securities[_symbol].Fundamentals.HasFundamentalData;

has_fundamental_data = self.securities[self._symbol].fundamentals.has_fundamental_data

Object References

If you save a reference to the Fundamentals fundamentals object or its properties, you can access the fundamental properties as they change over time.

_fundamentals = Securities[_symbol].Fundamentals;
var earningRatios = _fundamentals.EarningRatios;

self._fundamentals = self.securities[self._symbol].fundamentals
earning_ratios = self.fundamentals.earning_ratios

Universe Selection

You can access fundamental data in the selection function of your fundamental universe .

public class MyUniverseAlgorithm : QCAlgorithm {
    public override void Initialize() 
    {
        UniverseSettings.Asynchronous = true;
        AddUniverse(FundamentalFilterFunction);
    }
        
    private IEnumerable<Symbol> FundamentalFilterFunction(IEnumerable<Fundamental> fundamental) 
    {
         return (from f in fundamental
                where f.HasFundamentalData
                select f.Symbol);
    }
}

class MyUniverseAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.universe_settings.asynchronous = True
        self.add_universe(self._fundamental_function)
    
    def _fundamental_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
        return [c.symbol for c in fundamental if c.has_fundamental_data]

Historical Data

To get historical fundamental data, call the History history method. The return type depends on how you call the method.

var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);

// Fundamental objects
var fundamentalHistory = History<Fundamental>(ibm, TimeSpan.FromDays(30));

// Fundamentals objects for all US Equities (including delisted companies)
var fundamentalsHistory = History<Fundamentals>(TimeSpan.FromDays(30));

// Collection of Fundamental objects for all US Equities (including delisted companies)
var collectionHistory = History(_universe, 30, Resolution.Daily);
foreach (var fundamental in collectionHistory)
{
    // Cast to Fundamental is required
    var highestMarketCap = fundamental.OfType<Fundamental>().OrderByDescending(x => x.MarketCap).Take(5);
}

ibm = Symbol.create("IBM", SecurityType.EQUITY, Market.USA)

# Multi-index DataFrame objects
df_history = self.history(Fundamental, ibm, timedelta(30))

# Fundamental objects
fundamental_history = self.history[Fundamental](ibm, timedelta(30))

# Fundamentals objects for all US Equities (including delisted companies)
fundamentals_history = self.history[Fundamentals](timedelta(30))

# Multi-index Series objects of list of Fundamental objects
series_history = self.history(self._universe, 30, Resolution.DAILY)
for (universe_symbol, time), fundamental in series_history.items():
    highest_market_cap = sorted(fundamental, key=lambda x: x.market_cap)[-5:]

For more information about historical fundamental data, see Equity Fundamental Data .

Data Updates

The US Fundamental dataset only provides the originally-reported figures. If there was a mistake in reporting a figure, the data value isn't fixed later. In live trading, new fundamental data is available to your algorithms at approximately 6/7 AM Eastern Time (ET) each day. The majority of the corporate data update occurs once per month, but the financial ratios update daily. If there is no new data for a period of time, the previous data is filled forward.

Properties

The US Fundamentals dataset provides Fundamental objects. To filter Fundamental objects, you can use the MorningstarSectorCode , MorningstarIndustryGroupCode , and MorningstarIndustryCode enumeration values.

Fundamentals Attributes

Fundamentals objects have the following attributes:

MorningstarSectorCode Enumeration

Sectors are large super categories of data. To access the sector of an Equity, use the MorningstarSectorCode morningstar_sector_code property.

filtered = fundamental.Where(x => x.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology);

filtered = [x for x in fundamental if x.asset_classification.morningstar_sector_code == MorningstarSectorCode.TECHNOLOGY]

The MorningstarSectorCode enumeration has the following members:

MorningstarIndustryGroupCode Enumeration

Industry groups are clusters of related industries which tie together. To access the industry group of an Equity, use the MorningstarIndustryGroupCode morningstar_industry_group_code property.

filtered = fundamental.Where(x => x.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.ApplicationSoftware);

filtered = [x for x in fundamental if x.asset_classification.morningstar_industry_group_code == MorningstarIndustryGroupCode.APPLICATION_SOFTWARE]

The MorningstarIndustryGroupCode enumeration has the following members:

MorningstarIndustryCode Enumeration

Industries are the finest level of classification available and are the individual industries according to the Morningstar classification system. To access the industry group of an Equity, use the MorningstarIndustryCode morningstar_industry_code property:

filtered = fundamental.Where(x => x.AssetClassification.MorningstarIndustryCode == MorningstarIndustryCode.SoftwareApplication);

filtered = [x for x in fundamental if x.asset_classification.morningstar_industry_code == MorningstarIndustryCode.SOFTWARE_APPLICATION]

The MorningstarIndustryCode enumeration has the following members:

Exchange Id Values

Exchange Id is mapped to represent the exchange that lists the Equity. To access the exchange Id of an Equity, use the PrimaryExchangeID primary_exchange_id property.

filtered = fundamental.Where(x => x.CompanyReference.PrimaryExchangeID == "NAS");

filtered = [x for x in fundamental if x.company_reference.primary_exchange_id == "NAS"]

The exchanges are represented by the following string values:

Securities > Asset Classes > US Equity > Shorting

Introduction

In a regular long position, you buy shares and then sell them later to close the trade. In a short position, you borrow shares, sell them, and then buy the shares back later to close the trade. Short positions let you profit when a security's price decreases while you have the position open, but there are risks involved. For example, you can get a margin call and you may incur borrowing costs.

Holdings Accounting

If you have an open long position, your portfolio has a positive quantity of shares for that security. In contrast, if you have an open short position, your portfolio has a negative quantity of shares for that security.

Short Availability

To short sell, you need to borrow the shares from another investor or your brokerage. The short availability is the number of shares available for you to borrow. If you don't model the short availability in backtests, you could have a strategy that performs well in backtesting but doesn't trade in live mode because the shares aren't available to borrow. If you assume your short orders are successful in backtests, your backtesting results likely won't represent the true performance of actually trading the strategy during the backtest period. To get the short availability in your algorithms, use the US Equities Short Availability dataset . For more information about this topic, see Short Availability .

Borrowing Costs

In live trading, you usually pay a fee to borrow shares that you use to open a short position. Part of the fee goes to the investor that provided you with the opportunity to short with their shares. The borrowing rate is set by your live brokerage. In backtests, LEAN doesn't currently model borrowing costs, but we have an open GitHub Issue to add the functionality. Subscribe to GitHub Issue #4563 to track the feature progress.

Securities > Asset Classes > US Equity > Data Preparation

Introduction

The US Equities dataset provides price data for backtests and live trading.

Sourcing

The QuantConnect data provider consolidates US Equity market data across all of the exchanges. Over-the-Counter (OTC) trades are excluded. The data is powered by the Securities Information Processor (SIP), so it has 100% market coverage. In contrast, free platforms that display data feeds like the Better Alternative Trading System (BATS) only have about 6-7% market coverage .

We provide live splits, dividends, and corporate actions for US companies. We deliver them to your algorithm before the trading day starts.

Bar Building

We aggregate ticks to build bars.

The bar-building process can exclude ticks. If a tick is excluded, its volume is aggregated in the bar but its price is not aggregated in the bar. Ticks are excluded if any of the following statements are true:

• The tick is suspicious.
• The tick is from the FINRA exchange and meets our price and volume thresholds.
• The trade has none of the following included TradeConditionFlags and at least one of the following excluded TradeConditionFlags :
echo file_get_contents(DOCS_RESOURCES."/data-feeds/trade-condition-flags-table.html"); ?>
• The quote has a size of less than 100 shares.
• The quote has none of the following included QuoteConditionFlags and at least one of the following excluded QuoteConditionFlags :
• The quote has one of the following QuoteConditionFlags :
echo file_get_contents(DOCS_RESOURCES."/data-feeds/quote-condition-flags-table.html"); ?>

In the preceding tables, Participant refers to the entities on page 19 of the Consolidated Tape System Multicast Output Binary Specification .

Suspicious Ticks

Tick price data is raw and unfiltered, so it can contain a lot of noise. If a tick is not tradable, we flag it as suspicious. This process makes the bars a more realistic representation of what you could execute in live trading. If you use tick data, avoid using suspicious ticks in your algorithms as informative data points. We recommend only using tick data if you understand the risks and are able to perform your own tick filtering. Ticks are flagged as suspicious in the following situations:

• The tick occurs below the best bid or above the best ask


This image shows a tick that occurred above the best ask price of a security. The green line represents the best ask of the security, the blue line represents the best bid of the security, and the red dots represent trade ticks. The ticks between the best bid and ask occur from filling hidden orders. The tick that occurred above the best ask price is flagged as suspicious.

• The tick occurs far from the current market price


This image shows a tick that occurred far from the price of the security. The red dots represent trade ticks. The tick that occurred far from the market price is flagged as suspicious.

• The tick occurs on a dark pool
• The tick is rolled back
• The tick is reported late

Market Auction Prices

The opening and closing price of the day is set by very specific opening and closing auction ticks. When a stock like Apple is listed, it’s listed on Nasdaq. The open auction tick on Nasdaq is the price that’s used as the official open of the day. NYSE, BATS, and other exchanges also have opening auctions, but the only official opening price for Apple is the opening auction on the exchange where it was listed.

We set the opening and closing prices of the first and last bars of the day to the official auction prices. This process is used for second, minute, hour, and daily bars for the 9:30 AM and 4:30 PM Eastern Time (ET) prices. In contrast, other platforms might not be using the correct opening and closing prices.

The official auction prices are usually emitted 2-30 seconds after the market open and close. We do our best to use the official opening and closing prices in the bars we build, but the delay can be so large that there isn't enough time to update the opening and closing price of the bar before it's injected into your algorithms. For example, if you subscribe to second resolution data, we wait until the end of the second for the opening price but most second resolution data won’t get the official opening price. If you subscribe to minute resolution data, we wait until the end of the minute for the opening auction price. Most of the time, you’ll get the actual opening auction price with minute resolution data, but there are always exceptions. Nasdaq and NYSE can have delays in publishing the opening auction price, but we don’t have control over those issues and we have to emit the data on time so that you get the bar you are expecting.

Live and Backtesting Differences

In live trading, bars are built using the exchange timestamps with microsecond accuracy. This microsecond-by-microsecond processing of the ticks can mean that the individual bars between live trading and backtesting can have slightly different ticks. As a result, it's possible for a tick to be counted in different bars between backtesting and live trading, which can lead to bars having slightly different open, high, low, close, and volume values.

Data Availability

In live trading, live data is available in real-time. In backtests, live data is available at the following pre-market trading session.

Securities > Asset Classes > US Equity > Market Hours

Introduction

This page shows the trading hours, holidays, and time zone of the US Equity market.

Pre-market Hours

The following table shows the pre-market hours for the US Equity market:

Regular Trading Hours

The following table shows the regular trading hours for the US Equity market:

Post-market Hours

The following table shows the post-market hours for the US Equity market:

Holidays

LEAN uses the trading holidays from the NYSE website.

The following table shows the dates of holidays for the US Equity market:

Early Closes

The following table shows the early closes for the US Equity market:

Late Opens

There are no days with late opens.

Time Zone

The US Equity market trades in the America/New York time zone.

Securities > Asset Classes > India Equity

Securities > Asset Classes > India Equity > Requesting Data

Introduction

Request India Equity data in your algorithm to receive a feed of asset prices in the OnData on_data method. Historical data for backtesting is unavailable. To trade India Equities live, you can use one of the brokerage data providers .

Create Subscriptions

To create an India Equity subscription, in the Initialize initialize method, call the AddEquity add_equity method. The AddEquity add_equity method returns an Equity object, which contains a Symbol symbol property. Save a reference to the Symbol symbol so you can use it in OnData on_data to access the security data in the Slice .

_symbol = AddEquity("YESBANK", market: Market.India).Symbol;

self._symbol = self.add_equity("YESBANK", market=Market.INDIA).symbol

If you set the brokerage model to an India brokerage, you don't need to pass a market argument. To view the integrated brokerages that offer India Equities, see Brokerages .

Resolutions

The following table shows the available resolutions and data formats for India Equity subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick TICK
Second SECOND
Minute MINUTE
Hour HOUR
Daily DAILY

The default resolution for India Equity subscriptions is Resolution.Minute Resolution.MINUTE . To change the resolution, pass a resolution argument to the AddEquity add_equity method.

_symbol = AddEquity("YESBANK", Resolution.Daily, Market.India).Symbol;

self._symbol = self.add_equity("YESBANK", Resolution.DAILY, Market.INDIA).symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

LEAN groups all of the India Equity exchanges under Market.India Market.INDIA . To set the market for a security, pass a market argument to the AddEquity add_equity method.

_symbol = AddEquity("YESBANK", market: Market.India).Symbol;

self._symbol = self.add_equity("YESBANK", market=Market.INDIA).symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

_symbol = AddEquity("YESBANK", market: Market.India, fillForward: false).Symbol;

self._symbol = self.add_equity("YESBANK", market=Market.INDIA, fill_forward=False).symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of margin that's available depends on the brokerage model you use. For more information about the margin requirements of each brokerage, see the Margin section of the brokerage guides . To change the amount of leverage you can use for a security, pass a leverage argument to the AddEquity add_equity method.

_symbol = AddEquity("YESBANK", market: Market.India, leverage: 3).Symbol;

self._symbol = self.add_equity("YESBANK", market=Market.INDIA, leverage=3).symbol

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours extended_market_hours argument when you create the security subscription.

_symbol = AddEquity("YESBANK", market: Market.India, extendedMarketHours: true).Symbol;

self._symbol = self.add_equity("YESBANK", market=Market.India, extended_market_hours=True).Symbol

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours .

Data Normalization

The data normalization mode defines how historical data is adjusted for corporate actions . The data normalization mode affects the data that LEAN passes to OnData on_data and the data from history request . By default, LEAN adjusts India Equity data for splits and dividends to produce a smooth price curve, but the following data normalization modes are available:

If you use Adjusted ADJUSTED , SplitAdjusted SPLIT_ADJUSTED , or TotalReturn TOTAL_RETURN , we use the entire split and dividend history to adjust historical prices. This process ensures you get the same adjusted prices, regardless of the backtest end date. The ScaledRaw SCALED_RAW data normalization is only for history requests . When you use ScaledRaw SCALED_RAW , we use the split and dividend history before the algorithm's current time to adjust historical prices. The ScaledRaw SCALED_RAW data normalization model enables you to warm up indicators with adjusted data when you subscribe to Raw RAW security data.

To set the data normalization mode for a security, pass a dataNormalizationMode data_normalization_mode argument to the AddEquity add_equity method..

_symbol = AddEquity("YESBANK", market: Market.India, dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self._symbol = AddEquity("YESBANK", market=Market.INDIA, data_normalization_mode=DataNormalizationMode.RAW).symbol

Properties

The AddEquity add_equity method returns an Equity object, which have the following properties:

Securities > Asset Classes > India Equity > Handling Data

Introduction

LEAN passes the data you request to the OnData on_data method so you can make trading decisions. The default OnData on_data method accepts a Slice object, but you can define additional OnData on_data methods that accept different data types. For example, if you define an OnData on_data method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData on_data method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData on_data method, use the CurrentSlice current_slice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol symbol , but we recommend you use the Symbol symbol .

To view the resolutions that are available for India Equity data, see Resolutions .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars bars property of the Slice with the security Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    trade_bar = slice.bars.get(self._symbol)   # None if not found

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        close_price = trade_bar.close

Securities > Asset Classes > India Equity > Corporate Actions

Introduction

India Equity subscriptions provide notifications for splits, dividends, symbol changes, and delistings.

Splits

When a company does a stock split, the number of shares each shareholder owns increases and the price of each share decreases. When a company does a reverse stock split, the number of shares each shareholder owns decreases and the price of each share increases. A company may perform a stock split or a reverse stock split to adjust the price of their stock so that more investors trade it and the liquidity increases.

When a stock split or reverse stock split occurs for an Equity in your algorithm, LEAN sends a Split object to the OnData on_data method. Split objects have the following properties:

You receive Split objects when a split is in the near future and when it occurs. To know if the split occurs in the near future or now, check the Type type property.

If you backtest without the Raw RAW data normalization mode , the splits are factored into the price and volume. If you backtest with the Raw RAW data normalization mode or trade live, when a split occurs, LEAN automatically adjusts your positions based on the SplitFactor split_factor . If the post-split quantity isn't a valid lot size , LEAN credits the remaining value to your cashbook in your account currency. If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when splits occur so that the data in your indicators account for the price adjustments that the splits cause.

To get the Split objects, index the Splits splits object with the security Symbol symbol . The Splits splits object may not contain data for your Symbol . To avoid issues, check if the Splits splits object contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Splits.ContainsKey(_symbol))
    {
        var split = slice.Splits[_symbol];
    }
}

public override void OnSplits(Splits splits)
{
    if (splits.ContainsKey(_symbol))
    {
        var split = splits[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    split = slice.splits.get(self._symbol)
    if split:
        pass


def on_splits(self, splits: Splits) -> None:
    split = splits.get(self._symbol)
    if split:
        pass

You can also iterate through the Splits splits dictionary. The keys of the dictionary are the Symbol objects and the values are the Split objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

public override void OnSplits(Splits splits)
{
    foreach (var kvp in splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, split in slice.splits.items():
        pass

def on_splits(self, splits: Splits) -> None:
    for symbol, split in splits.items():
        pass

LEAN stores the data for stock splits in factor files. To view some example factor files, see the LEAN GitHub repository . In backtests, your algorithm receives Split objects at midnight. In live trading, your algorithm receives Split objects when the factor files are ready.

If you hold an Option contract for an underlying Equity when a split occurs, LEAN closes your Option contract position.

If a split event occurs before your order is filled, the unfilled portion of the order is adjusted automatically, where its quantity is multiplied by the split factor and the limit/stop/trigger price (if any) is divided by the split factor.

Dividends

A dividend is a payment that a company gives to shareholders to distribute profits. When a dividend payment occurs for an Equity in your algorithm, LEAN sends a Dividend object to the OnData on_data method. Dividend objects have the following properties:

If you backtest with the Adjusted ADJUSTED or TotalReturn TOTAL_RETURN data normalization mode, the dividends are factored into the price. If you backtest with the other data normalization modes or trade live, when a dividend payment occurs, LEAN automatically adds the payment amount to your cashbook. If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when dividend payments occur so that the data in your indicators account for the price adjustments that the dividend causes.

To get the Dividend objects, index the Dividends dividends object with the security Symbol symbol . The Dividends dividends object may not contain data for your Symbol symbol . To avoid issues, check if the Dividends dividends object contains data for your security before you index it with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Dividends.ContainsKey(_symbol))
    {
        var dividend = slice.Dividends[_symbol];
    }
}

public override void OnDividends(Dividends dividends)
{
    if (dividends.ContainsKey(_symbol))
    {
        var dividend = dividends[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    dividend = slice.dividends.get(self._symbol)
    if dividend:
        pass

def on_dividends(self, dividends: Dividends) -> None:
    dividend = dividends.get(self._symbol)
    if dividend:
        pass

You can also iterate through the Dividends dividends dictionary. The keys of the dictionary are the Symbol objects and the values are the Dividend objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

public override void OnDividends(Dividends dividends)
{
    foreach (var kvp in dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, dividend in slice.dividends.items():
        pass

def on_dividends(self, dividends: Dividends) -> None:
    for symbol, dividend in dividends.items():
        pass

For a full example, see the DividendAlgorithm DividendAlgorithm in the LEAN GitHub repository.

Symbol Changes

The benefit of the Symbol class is that it always maps to the same security, regardless of their trading ticker. When a company changes its trading ticker, LEAN sends a SymbolChangedEvent to the OnData on_data method. SymbolChangedEvent objects have the following properties:

To get the SymbolChangedEvent objects, index the SymbolChangedEvents symbol_changed_events object with the security Symbol symbol . The SymbolChangedEvents symbol_changed_events object may not contain data for your Symbol symbol . To avoid issues, check if the SymbolChangedEvents symbol_changed_events object contains data for your security before you index it with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.SymbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = slice.SymbolChangedEvents[_symbol];
    }
}

public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    if (symbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = symbolChangedEvents[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    symbol_changed_event = slice.symbol_changed_events.get(self._symbol)
    if symbol_changed_event:
        pass

def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    symbol_changed_event = symbol_changed_events.get(self._symbol)
    if symbol_changed_event:
        pass

You can also iterate through the SymbolChangedEvents symbol_changed_events dictionary. The keys of the dictionary are the Symbol objects and the values are the SymbolChangedEvent objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.SymbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    foreach (var kvp in symbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, symbol_changed_event in slice.symbol_changed_events.items():
        pass


def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    for symbol, symbol_changed_event in symbol_changed_events.items():
        pass

If you have an open order for a security when they change their ticker, LEAN cancels your order. To keep your order, in the OnOrderEvent on_order_event method, get the quantity and Symbol of the cancelled order and submit a new order.

public override void OnOrderEvent(OrderEvent orderEvent)
{
    if (orderEvent.Status == OrderStatus.Canceled)
    {
        var ticket = Transactions.GetOrderTicket(orderEvent.OrderId);
        if (ticket.Tag.Contains("symbol changed event"))
        {
            Transactions.AddOrder(ticket.SubmitRequest);
        }
    } 
}

def on_order_event(self, order_event: OrderEvent) -> None:
    if order_event.status == OrderStatus.CANCELED:
        ticket = self.transactions.get_order_ticket(order_event.order_id)
        if "symbol changed event" in ticket.tag:
            self.transactions.add_order(ticket.submit_request)

LEAN stores the data for ticker changes in map files. To view some example map files, see the LEAN GitHub repository .

Delistings

When a company is delisting from an exchange, LEAN sends a Delisting object to the OnData on_data method. Delisting objects have the following properties:

You receive Delisting objects when a delisting is in the near future and when it occurs. To know if the delisting occurs in the near future or now, check the Type property.

To get the Delisting objects, index the Delistings delistings object with the security Symbol symbol . The Delistings delistings objects may not contain data for your Symbol symbol . To avoid issues, check if the Delistings delistings object contains data for your security before you index it with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Delistings.ContainsKey(_symbol))
    {
        var delisting = slice.Delistings[_symbol];
    }
}

public override void OnDelistings(Delistings delistings)
{
    if (delistings.ContainsKey(_symbol))
    {
        var delisting = delistings[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    delisting = slice.delistings.get(self._symbol)
    if delisting:
        pass

def on_delistings(self, delistings: Delistings) -> None:
    delisting = delistings.get(self._symbol)
    if delisting:
        pass

You can also iterate through the Delistings delistings dictionary. The keys of the dictionary are the Symbol objects and the values are the Delisting objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

public override void OnDelistings(Delistings delistings)
{
    foreach (var kvp in delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, delisting in slice.Delistings.items():
        pass

def on_delistings(self, delistings: Delistings) -> None:
    for symbol, delisting in delistings.items():
        pass

The delist warning occurs on the final trading day of the stock to give you time to gracefully exit out of positions before LEAN automatically liquidates them.

if (delisting.Type == DelistingType.Warning)
{
    // Liquidate with MarketOnOpenOrder on delisting warning
    var quantity = Portfolio[symbol].Quantity;
    if (quantity != 0)
    {
        MarketOnOpenOrder(symbol, -quantity);
    }
}

if delisting.type == DelistingType.WARNING:
    # Liquidate with MarketOnOpenOrder on delisting warning
    quantity = self.portfolio[symbol].quantity
    if quantity != 0:
        self.market_on_open_order(symbol, -quantity)

The OnSecuritiesChanged on_securities_changed event notifies the algorithm when delisted assets are removed from the universe.

To improve iteration speed, LEAN removes delisted securities from the Securities securities primary collection. To access all the securities, iterate the Securities.Total securities.total property.

foreach (var security in Securities.Total)
{ 

}

// Exclude delisted securities
foreach (var security in Securities.Values)
{ 

}

for security in self.securities.total:
    pass

# Exclude delisted securities
for security in self.securities.values():
    pass

For a full example, see the DelistingEventsAlgorithm DelistingEventsAlgorithm in the LEAN GitHub repository.

Securities > Asset Classes > India Equity > Market Hours

Introduction

This page shows the trading hours, holidays, and time zone of the India Equity market.

Historical data for backtesting is unavailable for INDIA. In live trading, its data is sourced from the brokerage or a third-party data provider.

Pre-market Hours

The following table shows the pre-market hours for the India Equity market:

Regular Trading Hours

The following table shows the regular trading hours for the India Equity market:

Post-market Hours

The following table shows the post-market hours for the India Equity market:

Holidays

The following table shows the dates of holidays for the India Equity market:

Early Closes

There are no days with early closes.

Late Opens

There are no days with late opens.

Time Zone

The India Equity market trades in the Asia/Kolkata time zone.

Securities > Asset Classes > Equity Options

Securities > Asset Classes > Equity Options > Requesting Data

Introduction

Request Equity Options data in your algorithm to receive a feed of contract prices in the OnData on_data method. For more information about the specific dataset we use for backtests, see the US Equity Options dataset listing . To trade Equity Options live, you can use one of the brokerage data providers . We currently only support American-style Options for US Equity Options.

Create Subscriptions

Before you can subscribe to an Option contract, you must configure the underlying Equity and get the contract Symbol .

Configure the Underlying Equity

If you want to subscribe to the underlying Equity in the Initialize initialize method, set the Equity data normalization to DataNormalizationMode.Raw DataNormalizationMode.RAW .

_symbol = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self._symbol = self.add_equity("SPY", data_normalization_mode=DataNormalizationMode.RAW).symbol

If your algorithm has a dynamic universe of Equities, before you add the Equity universe in the Initialize initialize method, set the universe data normalization mode to DataNormalizationMode.Raw DataNormalizationMode.RAW .

UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;

self.universe_settings.data_normalization_mode = DataNormalizationMode.RAW

If you subscribe to an Equity Option contract but don't have a subscription to the underlying Equity, LEAN automatically subscribes to the underlying Equity with the following settings:

In this case, you still need the Equity Symbol to subscribe to Equity Option contracts. If you don't have access to it, create it.

_symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);

self._symbol = Symbol.create("SPY", SecurityType.EQUITY, Market.USA)

To override the initial guess of implied volatility , set and warm up the underlying volatility model .

Get Contract Symbols

To subscribe to an Option contract, you need the contract Symbol . You can get the contract Symbol from the CreateOption create_option method or from the OptionChainProvider option_chain_provider . If you use the CreateOption create_option method, you need to provide the details of an existing contract.

_contractSymbol = QuantConnect.Symbol.CreateOption(_symbol, Market.USA,
    OptionStyle.American, OptionRight.Call, 365, new DateTime(2022, 6, 17));

self._contract_symbol = Symbol.create_option(self._symbol, Market.USA,
    OptionStyle.AMERICAN, OptionRight.CALL, 365, datetime(2022, 6, 17))

Another way to get an Option contract Symbol is to use the OptionChainProvider option_chain_provider . The GetOptionContractList get_option_contract_list method of OptionChainProvider option_chain_provider returns a list of Symbol objects that reference the available Option contracts for a given underlying Equity on a given date. To filter and select contracts, you can use the following properties of each Symbol object:

var contractSymbols = OptionChainProvider.GetOptionContractList(_symbol, Time);
var expiry = contractSymbols.Select(symbol => symbol.ID.Date).Min();
var filteredSymbols = contractSymbols.Where(symbol => symbol.ID.Date == expiry && symbol.ID.OptionRight == OptionRight.Call);
_contractSymbol = filteredSymbols.OrderByDescending(symbol => symbol.ID.StrikePrice).Last();

contract_symbols = self.option_chain_provider.get_option_contract_list(self._symbol, self.time)
expiry = min([symbol.id.date for symbol in contract_symbols])
filtered_symbols = [symbol for symbol in contract_symbols if symbol.id.date == expiry and symbol.id.option_right == OptionRight.CALL]
self._contract_symbol = sorted(filtered_symbols, key=lambda symbol: symbol.id.strike_price)[0]

Subscribe to Contracts

To create an Equity Option contract subscription, pass the contract Symbol to the AddOptionContract add_option_contract method. Save a reference to the contract Symbol symbol so you can easily access the Option contract in the OptionChain that LEAN passes to the OnData on_data method. This method returns an Option object. To override the default pricing model of the Option, set a pricing model .

var option = AddOptionContract(_contractSymbol);
option.PriceModel = OptionPriceModels.BinomialCoxRossRubinstein();

option = self.add_option_contract(self._contract_symbol)
option.price_model = OptionPriceModels.binomial_cox_ross_rubinstein()

The AddOptionContract add_option_contract method creates a subscription for a single Option contract and adds it to your user-defined universe. To create a dynamic universe of Option contracts, add an Equity Options universe or an Options Universe Selection model .

Warm Up Contract Prices

If you subscribe to an Option contract with AddOptionContract add_option_contract , you'll need to wait until the next Slice to receive data and trade the contract. To trade the contract in the same time step you subscribe to the contract, set the current price of the contract in a security initializer .

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, seeder));

seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, seeder))

Supported Assets

To view the supported assets in the US Equities dataset, see the Data Explorer .

Resolutions

The following table shows the available resolutions and data formats for Equity Option contract subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick TICK
Second SECOND
Minute MINUTE
Hour HOUR
Daily DAILY

The default resolution for Option contract subscriptions is Resolution.Minute Resolution.MINUTE . To change the resolution, pass a resolution argument to the AddOptionContract add_option_contract method.

AddOptionContract(_contractSymbol, Resolution.Minute);

self.add_option_contract(self._contract_symbol, Resolution.MINUTE)

To create custom resolution periods, see Consolidating Data .

Supported Markets

LEAN groups all of the US Equity exchanges under Market.USA . You don't need to pass a Market market argument to the AddOptionContract add_option_contract method because the contract Symbol symbol already contains the market.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

AddOptionContract(_contractSymbol, fillForward: false);

self.add_option_contract(self._contract_symbol, fill_forward=False)

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. Options are already leveraged products, so you can't change their leverage.

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours extended_market_hours argument when you create the security subscription.

AddOptionContract(_contractSymbol, extendedMarketHours: true);

self.add_option_contract(self._contract_symbol, extended_market_hours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours .

Data Normalization

The data normalization mode doesn't affect the data that LEAN passes to OnData on_data or the data from history request . By default, LEAN doesn't adjust Equity Options data for splits and dividends of their underlying. If you change the data normalization mode, it won't change the outcome.

If you hold an Option contract when a corporate action occurs for the underlying Equity, LEAN automatically closes your position.

Remove Subscriptions

To remove a contract subscription that you created with AddOptionContract , call the RemoveOptionContract remove_option_contract method. This method is an alias for RemoveSecurity remove_security .

RemoveOptionContract(_contractSymbol);

self.remove_option_contract(self._contract_symbol)

The RemoveOptionContract remove_option_contract method cancels your open orders for the contract and liquidates your holdings.

Properties

The AddOptionContract method returns an Option object, which have the following properties:

Helper Methods

The Option object provides methods you can use for basic calculations. These methods require the underlying price. To get the Option object and the Security object for its underlying in any function, use the Option Symbol symbol to access the value in the Securities securities object.

var option = Securities[_contractSymbol];
var underlying = Securities[_contractSymbol.Underlying];
var underlyingPrice = underlying.Price;

option = self.securities[self._contract_symbol]
underlying = self.securities[self._contract_symbol.underlying]
underlying_price = underlying.price

To get the Option payoff , call the GetPayOff get_pay_off method.

var payOff = option.GetPayOff(underlyingPrice);

pay_off = option.get_pay_off(underlying_price)

To get the Option intrinsic value , call the GetIntrinsicValue get_intrinsic_value method.

var intrinsicValue = option.GetIntrinsicValue(underlyingPrice);

intrinsic_value = option.get_intrinsic_value(underlying_price)

To get the Option out-of-the-money amount , call the OutOfTheMoneyAmount out_of_the_money_amount method.

var otmAmount = option.OutOfTheMoneyAmount(underlyingPrice);

otm_amount = option.out_of_the_money_amount(underlying_price)

To check whether the Option can be automatic exercised, call the IsAutoExercised is_auto_exercised method.

var isAutoExercised = option.IsAutoExercised(underlyingPrice);

is_auto_exercised = option.is_auto_exercised(underlying_price)

Example

The following example shows how to update the Option chain every five minutes. The OptionChainManager class implements the selection logic and manages the contract subscriptions.

namespace QuantConnect.Algorithm.CSharp
{
    public class OptionChainProviderFullExample : QCAlgorithm
    {
        private Dictionary<Symbol, OptionChainManager> _chainManager = new();
        public override void Initialize()
        {
            SetStartDate(2023, 1, 2);
            SetEndDate(2023, 1, 30);
            SetCash(100000);
            UniverseSettings.Asynchronous = true;
            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
            SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
            var spy = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw).Symbol;
            _chainManager[QuantConnect.Symbol.CreateCanonicalOption(spy)] = new(-10, 10, 0, 7);
            PopulateOptionChain();
            Schedule.On(DateRules.EveryDay(spy), TimeRules.AfterMarketOpen(spy, 1), PopulateOptionChain);
            Schedule.On(DateRules.EveryDay(spy), TimeRules.Every(TimeSpan.FromMinutes(5)), Filter);
        }
        
        private void PopulateOptionChain()
        {
            // The contract list is updated daily, so we can get it and apply
            // the expiration filter as soon as the market open
            foreach (var (symbol, manager) in _chainManager)
            {
                manager.SetChain(OptionChainProvider.GetOptionContractList(symbol, Time), Time);
            }
    
            Filter();
        }
        
        private void Filter()
        {
            foreach (var (symbol, manager) in _chainManager)
            {
                manager.Select(this, symbol);
            }
        }
        
        public override void OnData(Slice slice)
        {
            foreach (var (symbol, manager) in _chainManager)
            {
                if (!slice.OptionChains.TryGetValue(symbol, out var chain))
                    continue;
                var expiry = chain.Min(x => x.Expiry);
                var atmCall = chain
                    .Where(x => x.Expiry == expiry && x.Right == OptionRight.Call && Securities[x.Symbol].IsTradable)
                    .OrderBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
                    .FirstOrDefault();

                if (atmCall != null && !Portfolio[atmCall.Symbol].Invested)
                    MarketOrder(atmCall.Symbol, 1);
            }
        }
    }

    internal class OptionChainManager
    {
        private readonly int _minStrike;
        private readonly int _maxStrike;
        private readonly int _minExpiry;
        private readonly int _maxExpiry;
        private List<Symbol> _chain = new();
        private readonly List<Symbol> _symbols = new();

        public OptionChainManager(int minStrike, int maxStrike, int minExpiry, int maxExpiry)
        {
            _minStrike = minStrike;
            _maxStrike = maxStrike;
            _minExpiry = minExpiry;
            _maxExpiry = maxExpiry;
        }

        public void SetChain(IEnumerable<Symbol> symbols, DateTime time)
        {
            _chain = symbols.Where(x =>
            {
                var totalDays = (x.ID.Date - time).TotalDays;
                return _minExpiry <= totalDays && totalDays <= _maxExpiry;
            }).ToList();
        }
        
        public void Select(QCAlgorithm algorithm, Symbol underlyingSymbol)
        {
            if (_chain.IsNullOrEmpty())
                return;
            if (underlyingSymbol.IsCanonical())
                underlyingSymbol = underlyingSymbol.Underlying;

            var strikes = _chain.Select(x => x.ID.StrikePrice).OrderBy(x => x).Distinct().ToList();
            var spot = algorithm.Securities[underlyingSymbol].Price;
            var atm = strikes.OrderBy(x => Math.Abs(spot - x)).FirstOrDefault();
            var index = strikes.IndexOf(atm);
            var minStrike = strikes[Math.Max(0, index + _minStrike)];
            var maxStrike = strikes[Math.Min(strikes.Count - 1, index + _maxStrike)];
            var symbols = _chain.Where(x => minStrike <= x.ID.StrikePrice && x.ID.StrikePrice <= maxStrike).ToList();

            var toRemove = _symbols.Except(symbols).ToList();
            foreach (var symbol in toRemove)
            {
                if (algorithm.RemoveOptionContract(symbol))
                    _symbols.Remove(symbol);
            }
            var toAdd = symbols.Except(_symbols).ToList();
            foreach (var symbol in toAdd)
            {
                _symbols.Add(symbol);
                algorithm.AddOptionContract(symbol);
            }
        }
    }
}

class OptionChainProviderFullExample(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2023, 1, 2)
        self.set_end_date(2023, 1, 30)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        self.universe_settings.minimum_time_in_universe = timedelta(minutes=0)
        self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))
        spy = self.add_equity("SPY", data_normalization_mode=DataNormalizationMode.RAW).symbol
        self._chain_manager = {
            Symbol.create_canonical_option(spy): OptionChainManager(-10, 10, 0, 7)
        }
        self._populate_option_chain()
        self.schedule.on(self.date_rules.every_day(spy), self.time_rules.after_market_open(spy, 1), self._populate_option_chain)
        self.schedule.on(self.date_rules.every_day(spy), self.time_rules.every(timedelta(minutes=5)), self._filter)

    def _populate_option_chain(self):
        # The contract list is updated daily, so we can get it and apply
        # the expiration filter as soon as the market open
        for symbol, manager in self._chain_manager.items():
            manager.set_chain(self.option_chain_provider.get_option_contract_list(symbol, self.time), self.time)
        self._filter()

    def _filter(self):
        for symbol, manager in self._chain_manager.items():
            manager.select(self, symbol)

    def on_data(self, slice: Slice) -> None:
        for symbol, _ in self._chain_manager.items():
            chain = slice.option_chains.get(symbol)
            if not chain: continue
            if self.portfolio[symbol.underlying].invested:
                self.liquidate(symbol.underlying)

            expiry = min([x.expiry for x in chain])
            contracts = [x for x in chain if x.expiry == expiry and x.right == OptionRight.CALL and self.securities[x.symbol].is_tradable]
            if not contracts: continue
            atm_call = sorted(contracts, key=lambda x: abs(chain.underlying.price-x.strike))[0]

            if not self.portfolio[atm_call.symbol].invested:
                self.market_order(atm_call.symbol, 1)

class OptionChainManager:
    _chain = []
    _symbols = []
    
    def __init__(self, min_strike, max_strike, min_expiry, max_expiry):
        self._min_strike = min_strike
        self._max_strike = max_strike
        self._min_expiry = min_expiry
        self._max_expiry = max_expiry
    
    def set_chain(self, symbols: List[Symbol], time: datetime) -> None:
        self._chain = [x for x in symbols if self._min_expiry <= (x.id.date - time).days <= self._max_expiry]
    
    def select(self, algorithm: QCAlgorithm, symbol: Symbol) -> None:
        if not self._chain:
            return
        if symbol.is_canonical():
            symbol = symbol.underlying
        strikes = sorted(set(x.id.strike_price for x in self._chain))
        spot = algorithm.securities[symbol].price
        atm = sorted(strikes, key=lambda x: abs(spot-x))[0]
        index = strikes.index(atm)
        min_strike = strikes[max(0, index + self._min_strike)]
        max_strike = strikes[min(len(strikes) - 1, index + self._max_strike)]
        symbols = set(x for x in self._chain if min_strike <= x.id.strike_price <= max_strike)
        to_remove = set(self._symbols).difference(symbols)
        for symbol in to_remove:
            if algorithm.remove_option_contract(symbol):
                self._symbols.remove(symbol)
        to_add = symbols.difference(self._symbols)
        for symbol in to_add:
            self._symbols.append(symbol)
            algorithm.add_option_contract(symbol)

Securities > Asset Classes > Equity Options > Handling Data

Introduction

LEAN passes the data you request to the OnData on_data method so you can make trading decisions. The default OnData on_data method accepts a Slice object, but you can define additional OnData on_data methods that accept different data types. For example, if you define an OnData on_data method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData on_data method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData on_data method, use the CurrentSlice current_slice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the contract ticker or Symbol symbol , but we recommend you use the Symbol symbol .

To view the resolutions that are available for Equity Options data, see Resolutions .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars bars property of the Slice with the contract Symbol symbol . If the contract doesn't actively trade or you are in the same time step as when you added the contract subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your contract before you index the Slice with the contract Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_contractSymbol))
    {
        var tradeBar = slice.Bars[_contractSymbol];
    }
}

def on_data(self, slice: Slice) -> None:
    trade_bar = slice.bars.get(self._contract_symbol)   # None if not found

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        close_price = trade_bar.close

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open open , High high , Low low , and Close close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open open , High high , Low low , and Close close properties of the QuoteBar copy the values of either the Bid bid or Ask ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the contract Symbol symbol . If the contract doesn't actively get quotes or you are in the same time step as when you added the contract subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your contract before you index the Slice with the contract Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_contractSymbol))
    {
        var quoteBar = slice.QuoteBars[_contractSymbol];
    }
}

def on_data(self, slice: Slice) -> None:
    quote_bar = slice.quote_bars.get(self._contract_symbol)   # None if not found

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.quote_bars.items():
        ask_price = quote_bar.ask.close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Option Chains

OptionChain objects represent an entire chain of Option contracts for a single underlying security. They have the following properties:

To get the OptionChain , index the OptionChains option_chains property of the Slice with the canonical Symbol .

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        var contracts = chain.Contracts;
    }
}

def on_data(self, slice: Slice) -> None:
    chain = slice.option_chains.get(self._contract_symbol.Canonical)
    if chain:
        contracts = chain.contracts

You can also loop through the OptionChains option_chains property to get each OptionChain .

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.OptionChains)
    {
        var canonicalSymbol = kvp.Key;
        var chain = kvp.Value;
        var contracts = chain.Contracts;
    }
}

def on_data(self, slice: Slice) -> None:
    for canonical_symbol, chain in slice.option_chains.items():
        contracts = chain.contracts

Option Contracts

OptionContract objects represent the data of a single Option contract in the market. They have the following properties:

To get the Option contracts in the Slice , use the Contracts contracts property of the OptionChain .

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var price = contract.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    chain = slice.option_chains.get(self._contract_symbol.canonical)
    if chain:
        contract = chain.contracts.get(self._contract_symbol)
        if contract:
            price = contract.price

Greeks and Implied Volatility

To get the Greeks and implied volatility of an Option contract, use the Greeks greeks and implied_volatility members.

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var delta = contract.Greeks.Delta;
            var iv = contract.ImpliedVolatility;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    chain = slice.option_chains.get(self._contract_symbol.canonical)
    if chain:
        contract = chain.contracts.get(self._contract_symbol)
        if contract:
            delta = contract.greeks.delta
            iv = contract.implied_volatility

LEAN only calculates Greeks and implied volatility when you request them because they are expensive operations. If you invoke the Greeks greeks property, the Greeks aren't calculated. However, if you invoke the Greeks.Delta greeks.delta , LEAN calculates the delta. To avoid unecessary computation in your algorithm, only request the Greeks and implied volatility when you need them. For more information about the Greeks and implied volatility, see Options Pricing .

Open Interest

Open interest is the number of outstanding contracts that haven't been settled. It provides a measure of investor interest and the market liquidity, so it's a popular metric to use for contract selection. Open interest is calculated once per day. To get the latest open interest value, use the OpenInterest open_interest property of the Option or OptionContract Optioncontract .

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var openInterest = contract.OpenInterest;
        }
    }
}

public void OnData(OptionChains optionChains)
{
    if (optionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var openInterest = contract.OpenInterest;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    chain = slice.OptionChains.get(self._contract_symbol.canonical)
    if chain:
        contract = chain.contracts.get(self._contract_symbol)
        if contract:
            open_interest = contract.open_interest

Securities > Asset Classes > Equity Options > Greeks and Implied Volatility

Securities > Asset Classes > Equity Options > Greeks and Implied Volatility > Key Concepts

Option Pricing

As derivatives, Options are subject to a zero-sum game dynamic, necessitating counterparties to take opposing positions. Consequently, it is essential to accurately determine the fair value of an Option to avoid potential disadvantages resulting from counterparties. It's possible to calculate the theoretical value of an Option using only its own terms and the underlying price series expectations.

where $P$ is the Option price, $S_t$ is the current underlying price, $K$ is the strike price, $\sigma$ is the volatility, $T$ is the expiry, $r$ is the continuous interest rate, and $q$ is the continuous dividend yield.

With a correct Option pricing model , arbitrage traders capitalize on market inefficiencies, speculation traders can trade on the underlying price expectation or volatility, and risk/portfolio managers can hedge their positions to perfectly reduce risk exposure. The following sections describe popular Option pricing models.

Black-Scholes-Merton (BSM) Framework

This framework operates on the assumption of a log-normal stochastic process governing underlying price dynamics. Its appeal stems from its continuous modeling approach and provision of closed-form analytical solutions, rendering it particularly amenable to real-world scenarios. Nevertheless, it has faced scrutiny for its reliance on assumptions of constant volatility and interest rates. It's primarily employed in the valuation of European Options, so utility wanes in situations where early exercise risk is significant.

Lattice Models

These encompass prevalent models such as the Binomial Tree and Trinomial Tree. Unlike the BSM model, lattice models adopt a discrete process framework lacking an analytical solution, necessitating numerical methods and substantial computational resources for the solution. However, they offer the advantage of facilitating the calculation of early exercise payoffs at each time step, making it a suitable tool on pricing American Options.

Monte Carlo Simulation

Particularly relevant for the pricing of exotic Options devoid of explicit analytical frameworks, Monte Carlo simulations serve as indispensable tools for estimating the expected fair Option prices. Despite their computational complexity and time-intensive nature, these simulations, including methods like Markov-Chain Monte Carlo, play a pivotal role in pricing certain Options.

Implied Volatility

Failure of Historical Volatility

It is worth noting that all these pricing models have a volatility input, as to account for the future price expectation. However, the conventional approach of using historical volatility to predict future price uncertainty has faced criticism due to its assumption of time-invariant volatility, which fails to capture the dynamic nature of stock price distributions. This assumption overlooks the observed fat-tailed and evolving characteristics of price distributions over time. Consequently, employing such assumptions in Option pricing models derived from the underlying stock may lead to pricing inaccuracies. For example, examining the Brownian Motion stochastic differential formula within the Black-Scholes-Merton (BSM) framework: $$ dS_t = \mu S_t dt + \sigma S_t dW_t^S $$ In this equation, the parameter $\sigma$ denotes volatility, assumed to be constant. However, this assumption is unrealistic, as any movement in the underlying asset's price naturally induces fluctuations.

Local and Stochastic Volatility

One effective approach involves employing an alternative measure of volatility. This strategy is intuitive, as deviations of a stock's price from its current expected value typically correspond to increased variance in the series of price changes. This alternative measure can be broken down into stochastic and local volatility components.

Mathematically, stochastic volatility can be represented by the following stochastic differential equation: $$ d\sigma_t=\alpha(t,\sigma_t)dt + \beta(t,\sigma_t)dW_t^\sigma $$ On the other hand, local volatility, which is deterministic, serves as a parameterization of the volatility term within the original price Brownian Motion. Notable examples of local volatility models include the Dupire local volatility model ( details ). It is worth noting that many models utilize past volatility as a predictive input for future volatility. This approach is justified by the observation of volatility clustering, where volatility tends to persist at similar levels over short time frames.

Implied Volatility and Its Importance

If we view volatility modeling as a prospective approach, implied volatility (IV) can be understood as a retrospective, backward-looking measure derived from a chosen option pricing model. Following the no-arbitrage assumption, if we consider the market option price as the fair, theoretical price, we can use the current option price, along with other known variables, to determine the "fair" volatility value implied by the specific pricing model.

Implied volatility serves not only as the output of the pricing formula's inverse but also as an input for option Greeks, which we will discuss subsequently, as it represents a "correct" and risk-adjusted measure of volatility. Accurate implied volatility is crucial for calculating the correct Greeks for both trading and hedging purposes. Additionally, implied volatility offers insights into the likelihood of a stock moving toward a specific price level, thereby serving as valuable data points for regression analysis in the modeling process or to assess the accuracy of the model.

While modeling implied volatility can enhance pricing accuracy, some traders leverage implied volatility for volatility trading, as it tends to be more predictable due to volatility clustering. This concept can be implemented through trading composite Option strategies such as Straddles and an Iron Condor .

Greeks

Option Greeks represent the changes of an option's price concerning changes in specific parameters. They serve as indicators of the sensitivity of an option's value to variations in these parameters, effectively quantifying the impact of each component on the final option price. The table below outlines some of the most commonly used Option Greeks:

Option Greeks are the partial derivatives of the option price. Therefore, their values are also a function of the IV. This stresses the importance of an accurate IV model to obtain accurate Greeks, hence accurate hedge size calculation for option hedging methods like Delta hedging.

Volatility Smile

The "volatility smile" is a term used in finance to describe a particular shape that can be observed when plotting IV against strike prices for options that share the same expiration date. Typically, when you plot IVs against strike prices, the curve tends to be concave, resembling a smile. This means that options with strike prices significantly above or below the current market price of the underlying asset tend to have higher IV than options with strike prices closer to the current market price.

Several theories attempt to explain the existence of the volatility smile. One explanation is that it arises from adjustments to the classic Black-Scholes-Merton (BSM) model, which assumes that asset prices follow a log-normal distribution. The volatility smile suggests that the market anticipates a higher probability of extreme price movements (fat tails) than the BSM model predicts. Another explanation is related to market dynamics and the demand for hedging. During periods of heightened market volatility, the volatility smile tends to become steeper, indicating a greater disparity in implied volatilities across different strike prices. This means that options, particularly those with out-of-the-money strike prices, become more expensive as investors seek protection against potential market downturns or increased price fluctuations. As a result, the volatility smile can serve as a valuable tool for investors and traders to assess market sentiment and gauge the level of risk in their portfolios.

According to some volatility models, such as the Heston model, the IV smile/surface should exhibit a smooth pattern. Any deviations from this smoothness, such as non-smooth spikes or irregularities, may signal potential arbitrage opportunities for traders.

Volatility Smirk

However, in some cases, rather than a traditional U-shaped curve, traders may observe what's known as a "smirk." This smirk occurs when the implied volatilities for higher-strike options are lower than those for ATM and lower-strike options. This deviation from the typical volatility smile pattern indicates a market expectation of a significant downward movement in the underlying asset's price. Traders interpret this as a signal that investors are allocating funds towards options with higher probabilities of such downward movements, resulting in increased demand for lower-strike options.

Volatility Smoothing

Volatility smoothing refers to the creation of a smooth volatility smile/surface. Derivative like options are favorable for maket-making and arbitration trading, due to the existence of fair price modeling. In the contemporary domain of high-frequency trading, the efficiency of calculating IV and Greeks assumes paramount significance. Thus, the quest for swift and refined IV surface computation becomes an inevitable quest for traders. Rather than relying solely on conventional methods involving slow-paced sampling and continuous parameter recalibration, the adoption of approximation techniques and stationary state analyses gains traction, especially in the context of IV estimation.

Accuracy Consideration

The Law of One Price stipulates the existence of a singular fair price for any given underlying asset. Consequently, according to the principles of put-call parity, each strike price for European options at expiration should correspond to a unique IV value. Within the realm of the Black-Scholes-Merton (BSM) framework, for instance, the concept of put-call parity yields insights into the equivalence of IVs for call and put options at identical strike prices and expirations. This equivalence serves as the foundation for formulating objective function: $$ C(t,K) - P(t,K)=e^{(q-r)t} (S_T - K) \\\Rightarrow e^{(q-r)t} [S_T (\Phi(d_{+}^{call})+\Phi(-d_{+}^{put})) - K (\Phi(d_{-}^{call})+\Phi(-d_{-}^{put}))] = e^{(q-r)t} (S_T - K) \\\Rightarrow \Phi(d_{+}^{call})+\Phi(-d_{+}^{put}) = 1\ \text{and}\ \Phi(d_{-}^{call})+\Phi(-d_{-}^{put}) = 1 \\\Rightarrow d_{\pm}^{call}=d_{\pm}^{put} $$ Thus, we can formulate an objective function of $C_{market} + P_{market} = C_{BSM} + P_{BSM}$.

Alternatively, certain schools of thought contend that the bulk of historical volatility information is encapsulated within at-the-money (ATM) options, with any residual volatility attributable to the extrinsic value of the option. Consequently, a strategy focused on out-of-the-money (OTM) options for IV calculations gains traction.

Speed Consideration

In the realm of high-frequency trading, where split-second decisions are the norm, the traditional process of sampling, evaluating, recalibrating, and deriving implied volatility expectations is simply unfeasible. In response, traders and analysts increasingly turn to polynomial regression techniques as a pragmatic solution for IV modeling.

For example, $$ IV_t = \beta_0 + \beta_1 M + \beta_2 M^2 + \beta_3 (T-t) + \beta_4 (T-t)^2 + \beta_5 M(T-t) \\\text{where} M = ln(S_t/K) $$

Additionally, the utilization of advanced mathematical algorithms, such as the Fast Fourier Transform (FFT), enables the rapid computation of the entire Greek surface, enhancing speed and efficiency. While these approaches may entail minor trade-offs in terms of accuracy, the overarching objective remains the attainment of a seamlessly smooth implied volatility surface that fosters effective arbitrage strategies.

Securities > Asset Classes > Equity Options > Greeks and Implied Volatility > Option Indicators

Introduction

This page explains the most popular Option indicators and how to use them with LEAN.

Parameters

The following table describes the arguments that the automatic Option indicators methods accept:

To perform implied volatility (IV) smoothing with a put-call pair, pass one of the contracts as the symbol argument and pass the other contract in the pair as the mirrorOption mirror_option argument. The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, call the SetSmoothingFunction set_smoothing_function method of the ImpliedVolatility class/property.

Several different Option pricing models are supported to calculate the IV and Greeks. The following table describes the OptionPricingModelType enumeration members:

Implied Volatility

Implied volatility, $\sigma$ , is the market's expectation for the future volatility of an asset and is implied by the price of the assets's Options contracts. You can't observe it in the market but you can derive it from the price of an Option. For more information about implied volatility, see Implied Volatility .

Automatic Indicators

To create an automatic indicator for implied volatility, call the QCAlgorithm.IV QCAlgorithm.iv method with the Option contract Symbol symbol object(s).

private ImpliedVolatility _impliedvolatility;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    // Example of using the single-contract IV calculation:
    _impliedvolatility = IV(option);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _impliedvolatility = IV(option, mirrorOption);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    # Example of using the single-contract IV calculation:
    self._impliedvolatility = self.iv(option)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._impliedvolatility = self.iv(option, mirror_option)

The follow table describes the arguments that the IV iv method accepts in addition to the standard parameters :

For more information about the IV iv method, see Using IV Indicator .

Manual Indicators

To create a manual indicator for implied volatility, call the ImpliedVolatility constructor.

private ImpliedVolatility _impliedvolatility;

public override void Initialize()
{
    var equity = AddEquity("AAPL").Symbol;
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var interestRateProvider = new InterestRateProvider();
    var dividendYieldProvider = new DividendYieldProvider(equity);

    // Example of using the single-contract IV calculation:
    _impliedvolatility = new ImpliedVolatility(option, interestRateProvider, dividendYieldProvider);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _impliedvolatility = new ImpliedVolatility(option, interestRateProvider, dividendYieldProvider, mirrorOption);
}

def initialize(self):
    equity = self.add_equity("AAPL").symbol
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    interest_rate_provider = InterestRateProvider()
    dividend_yield_provider = DividendYieldProvider(equity)

    # Example of using the single-contract IV calculation:
    self._impliedvolatility = ImpliedVolatility(option, interest_rate_provider, dividend_yield_provider)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._impliedvolatility = ImpliedVolatility(option, interest_rate_provider, dividend_yield_provider, mirror_option)

For more information about the ImpliedVolatility constructor, see Using IV Indicator .

Volatility Smoothing

The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, pass a mirrorOption mirror_option argument to the IV iv method or ImpliedVolatility constructor and then call the SetSmoothingFunction set_smoothing_function method of the resulting ImpliedVolatility object. The follow table describes the arguments of the custom function:

The method must return a decimal float as the smoothened IV.

private ImpliedVolatility _iv;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);

    _iv = IV(option, mirrorOption);
    // example: take average of the call-put pair
    _iv.SetSmoothingFunction((iv, mirrorIv) => (iv + mirrorIv) * 0.5m);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)

    self._iv = self.iv(option, mirror_option)
    # Example: The average of the call-put pair.
    self._iv.set_smoothing_function(lambda iv, mirror_iv: (iv + mirror_iv) * 0.5)

Delta

Delta, $\Delta$ , is the rate of change of the Option price with respect to the price of the underlying asset. It measures the first-order sensitivity of the price to a movement in underlying price. For example, an Option delta of 0.4 means that if the underlying asset moves by 1%, then the value of the Option moves by 0.4 × 1% = 0.4%. For more information about delta, see Delta .

Automatic Indicators

To create an automatic indicator for delta, call the QCAlgorithm.D QCAlgorithm.d method with the Option contract Symbol symbol object(s).

private Delta _delta;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    // Example of using the single-contract IV calculation:
    _delta = D(option);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _delta = D(option, mirrorOption);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    # Example of using the single-contract IV calculation:
    self._delta = self.d(option)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._delta = self.d(option, mirror_option)

The follow table describes the arguments that the D method accepts in addition to the standard parameters :

For more information about the D method, see Using D Indicator .

Manual Indicators

To create a manual indicator for delta, call the Delta constructor.

private Delta _delta;

public override void Initialize()
{
    var equity = AddEquity("AAPL").Symbol;
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var interestRateProvider = new InterestRateProvider();
    var dividendYieldProvider = new DividendYieldProvider(equity);

    // Example of using the single-contract IV calculation:
    _delta = new Delta(option, interestRateProvider, dividendYieldProvider);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _delta = new Delta(option, interestRateProvider, dividendYieldProvider, mirrorOption);
}

def initialize(self):
    equity = self.add_equity("AAPL").symbol
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    interest_rate_provider = InterestRateProvider()
    dividend_yield_provider = DividendYieldProvider(equity)

    # Example of using the single-contract IV calculation:
    self._delta = Delta(option, interest_rate_provider, dividend_yield_provider)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._delta = Delta(option, interest_rate_provider, dividend_yield_provider, mirror_option)

For more information about the Delta constructor, see Using D Indicator .

Volatility Smoothing

The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, pass a mirrorOption mirror_option argument to the indicator method or constructor and then call the SetSmoothingFunction set_smoothing_function method of the ImpliedVolatility property of the indicator.

// Example: Average IV of the call-put pair.
_delta.ImpliedVolatility.SetSmoothingFunction((iv, mirrorIv) => (iv + mirrorIv) * 0.5m);

# Example: Average IV of the call-put pair.
self._delta.implied_volatility.set_smoothing_function(lambda iv, mirror_iv: (iv + mirror_iv) * 0.5)

For more information about the IV smoothing function, see Implied Volatility .

Gamma

Gamma, $\Gamma$ , is the rate of change of the portfolio's delta with respect to the underlying asset's price. It represents the second-order sensitivity of the Option to a movement in the underlying asset's price. For more information about Gamma, see Gamma .

Automatic Indicators

To create an automatic indicator for gamma, call the QCAlgorithm.G QCAlgorithm.g method with the Option contract Symbol symbol object(s).

private Gamma _gamma;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    // Example of using the single-contract IV calculation:
    _gamma = G(option);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _gamma = G(option, mirrorOption);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    # Example of using the single-contract IV calculation:
    self._gamma = self.g(option)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._gamma = self.g(option, mirror_option)

The follow table describes the arguments that the G method accepts in addition to the standard parameters :

For more information about the G method, see Using G Indicator .

Manual Indicators

To create a manual indicator for gamma, call the Gamma constructor.

private Gamma _gamma;

public override void Initialize()
{
    var equity = AddEquity("AAPL").Symbol;
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var interestRateProvider = new InterestRateProvider();
    var dividendYieldProvider = new DividendYieldProvider(equity);

    // Example of using the single-contract IV calculation:
    _gamma = new Gamma(option, interestRateProvider, dividendYieldProvider);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _gamma = new Gamma(option, interestRateProvider, dividendYieldProvider, mirrorOption);
}

def initialize(self):
    equity = self.add_equity("AAPL").symbol
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    interest_rate_provider = InterestRateProvider()
    dividend_yield_provider = DividendYieldProvider(equity)

    # Example of using the single-contract IV calculation:
    self._gamma = Gamma(option, interest_rate_provider, dividend_yield_provider)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._gamma = Gamma(option, interest_rate_provider, dividend_yield_provider, mirror_option)

For more information about the Gamma constructor, see Using G Indicator .

Volatility Smoothing

The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, pass a mirrorOption mirror_option argument to the indicator method or constructor and then call the SetSmoothingFunction set_smoothing_function method of the ImpliedVolatility property of the indicator.

// Example: Average IV of the call-put pair.
_gamma.ImpliedVolatility.SetSmoothingFunction((iv, mirrorIv) => (iv + mirrorIv) * 0.5m);

# Example: Average IV of the call-put pair.
self._gamma.implied_volatility.set_smoothing_function(lambda iv, mirror_iv: (iv + mirror_iv) * 0.5)

For more information about the IV smoothing function, see Implied Volatility .

Vega

Vega, $\nu$ , is the rate of change in the value of the Option with respect to the volatility of the underlying asset. For more information about vega, see Vega .

Automatic Indicators

To create an automatic indicator for vega, call the QCAlgorithm.V QCAlgorithm.v method with the Option contract Symbol symbol object(s).

private Vega _vega;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    // Example of using the single-contract IV calculation:
    _vega = V(option);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _vega = V(option, mirrorOption);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    # Example of using the single-contract IV calculation:
    self._vega = self.v(option)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._vega = self.v(option, mirror_option)

The follow table describes the arguments that the V method accepts in addition to the standard parameters :

For more information about the V method, see Using V Indicator .

Manual Indicators

To create a manual indicator for vega, call the Vega constructor.

private Vega _vega;

public override void Initialize()
{
    var equity = AddEquity("AAPL").Symbol;
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var interestRateProvider = new InterestRateProvider();
    var dividendYieldProvider = new DividendYieldProvider(equity);

    // Example of using the single-contract IV calculation:
    _vega = new Vega(option, interestRateProvider, dividendYieldProvider);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _vega = new Vega(option, interestRateProvider, dividendYieldProvider, mirrorOption);
}

def initialize(self):
    equity = self.add_equity("AAPL").symbol
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    interest_rate_provider = InterestRateProvider()
    dividend_yield_provider = DividendYieldProvider(equity)

    # Example of using the single-contract IV calculation:
    self._vega = Vega(option, interest_rate_provider, dividend_yield_provider)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._vega = Vega(option, interest_rate_provider, dividend_yield_provider, mirror_option)

For more information about the Vega constructor, see Using V Indicator .

Volatility Smoothing

The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, pass a mirrorOption mirror_option argument to the indicator method or constructor and then call the SetSmoothingFunction set_smoothing_function method of the ImpliedVolatility property of the indicator.

// Example: Average IV of the call-put pair.
_vega.ImpliedVolatility.SetSmoothingFunction((iv, mirrorIv) => (iv + mirrorIv) * 0.5m);

# Example: Average IV of the call-put pair.
self._vega.implied_volatility.set_smoothing_function(lambda iv, mirror_iv: (iv + mirror_iv) * 0.5)

For more information about the IV smoothing function, see Implied Volatility .

Theta

Theta, $\Theta$ , is the rate of change of the value of the Option with respect to the passage of time. It is also known to as the time decay of an Option. For more information about theta, see Theta .

Automatic Indicators

To create an automatic indicator for theta, call the QCAlgorithm.T QCAlgorithm.t method with the Option contract Symbol symbol object(s).

private Theta _theta;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    // Example of using the single-contract IV calculation:
    _theta = T(option);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _theta = T(option, mirrorOption);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    # Example of using the single-contract IV calculation:
    self._theta = self.t(option)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._theta = self.t(option, mirror_option)

The follow table describes the arguments that the T method accepts in addition to the standard parameters :

For more information about the T method, see Using T Indicator .

Manual Indicators

To create a manual indicator for theta, call the Theta constructor.

private Theta _theta;

public override void Initialize()
{
    var equity = AddEquity("AAPL").Symbol;
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var interestRateProvider = new InterestRateProvider();
    var dividendYieldProvider = new DividendYieldProvider(equity);

    // Example of using the single-contract IV calculation:
    _theta = new Theta(option, interestRateProvider, dividendYieldProvider);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _theta = new Theta(option, interestRateProvider, dividendYieldProvider, mirrorOption);
}

def initialize(self):
    equity = self.add_equity("AAPL").symbol
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    interest_rate_provider = InterestRateProvider()
    dividend_yield_provider = DividendYieldProvider(equity)

    # Example of using the single-contract IV calculation:
    self._theta = Theta(option, interest_rate_provider, dividend_yield_provider)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._theta = Theta(option, interest_rate_provider, dividend_yield_provider, mirror_option)

For more information about the Theta constructor, see Using T Indicator .

Volatility Smoothing

The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, pass a mirrorOption mirror_option argument to the indicator method or constructor and then call the SetSmoothingFunction set_smoothing_function method of the ImpliedVolatility property of the indicator.

// Example: Average IV of the call-put pair.
_theta.ImpliedVolatility.SetSmoothingFunction((iv, mirrorIv) => (iv + mirrorIv) * 0.5m);

# Example: Average IV of the call-put pair.
self._theta.implied_volatility.set_smoothing_function(lambda iv, mirror_iv: (iv + mirror_iv) * 0.5)

For more information about the IV smoothing function, see Implied Volatility .

Rho

Rho, $\rho$ , is the rate of change of the value of a derivative with respect to the interest rate.  It is usually small and not a big issue in practice unless the Option is deep in-the-money and has a long horizon. In this case, the interest rate matters because you need to discount a larger cash flow over a longer horizon. For more information about rho, see Rho .

Automatic Indicators

To create an automatic indicator for rho, call the QCAlgorithm.R QCAlgorithm.r method with the Option contract Symbol symbol object(s).

private Rho _rho;

public override void Initialize()
{
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    // Example of using the single-contract IV calculation:
    _rho = R(option);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _rho = R(option, mirrorOption);
}

def initialize(self):
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    # Example of using the single-contract IV calculation:
    self._rho = self.r(option)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._rho = self.r(option, mirror_option)

The follow table describes the arguments that the R method accepts in addition to the standard parameters :

Manual Indicators

To create a manual indicator for rho, call the Rho constructor.

private Rho _rho;

public override void Initialize()
{
    var equity = AddEquity("AAPL").Symbol;
    var option = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Put, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(option);

    var interestRateProvider = new InterestRateProvider();
    var dividendYieldProvider = new DividendYieldProvider(equity);

    // Example of using the single-contract IV calculation:
    _rho = new Rho(option, interestRateProvider, dividendYieldProvider);

    // Example of using the using mirror-contract IV calculation:
    var mirrorOption = QuantConnect.Symbol.CreateOption("AAPL", Market.USA, OptionStyle.American, OptionRight.Call, 505m, new DateTime(2014, 6, 27));
    AddOptionContract(mirrorOption);
    _rho = new Rho(option, interestRateProvider, dividendYieldProvider, mirrorOption);
}

def initialize(self):
    equity = self.add_equity("AAPL").symbol
    option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.PUT, 505, datetime(2014, 6, 27))
    self.add_option_contract(option)

    interest_rate_provider = InterestRateProvider()
    dividend_yield_provider = DividendYieldProvider(equity)

    # Example of using the single-contract IV calculation:
    self._rho = Rho(option, interest_rate_provider, dividend_yield_provider)

    # Example of using the using mirror-contract IV calculation:
    mirror_option = Symbol.create_option("AAPL", Market.USA, OptionStyle.AMERICAN, OptionRight.CALL, 505, datetime(2014, 6, 27))
    self.add_option_contract(mirror_option)
    self._rho = Rho(option, interest_rate_provider, dividend_yield_provider, mirror_option)

For more information about the Rho constructor, see Using R Indicator .

Volatility Smoothing

The default IV smoothing method uses the one contract in the pair that's at-the-money or out-of-money to calculate the IV. To change the smoothing function, pass a mirrorOption mirror_option argument to the indicator method or constructor and then call the SetSmoothingFunction set_smoothing_function method of the ImpliedVolatility property of the indicator.

// Example: Average IV of the call-put pair.
_rho.ImpliedVolatility.SetSmoothingFunction((iv, mirrorIv) => (iv + mirrorIv) * 0.5m);

# Example: Average IV of the call-put pair.
self._rho.implied_volatility.set_smoothing_function(lambda iv, mirror_iv: (iv + mirror_iv) * 0.5)

For more information about the IV smoothing function, see Implied Volatility .

Examples

Securities > Asset Classes > Equity Options > Market Hours

Introduction

This page shows the trading hours, holidays, and time zone of the Equity Option market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the Equity Option market:

Post-market Hours

Post-market trading is not available.

Holidays

LEAN uses the trading holidays from the NYSE website.

The following table shows the dates of holidays for the Equity Option market:

Early Closes

The following table shows the early closes for the Equity Option market:

Late Opens

There are no days with late opens.

Time Zone

The Equity Option market trades in the America/New York time zone.

Securities > Asset Classes > Crypto

Securities > Asset Classes > Crypto > Requesting Data

Introduction

Request Crypto data in your algorithm to receive a feed of asset prices in the OnData on_data method. For more information about the specific datasets we use for backtests, see the CoinAPI datasets . To trade Crypto live, you can use the QuantConnect data provider .

Create Subscriptions

To create a Crypto subscription, in the Initialize initialize method, call the AddCrypto add_crypto method. The AddCrypto add_crypto method returns a Crypto object, which contains a Symbol symbol property. Save a reference to the Symbol symbol so you can use it in OnData on_data to access the security data in the Slice .

_symbol = AddCrypto("BTCUSD").Symbol;

self._symbol = self.add_crypto("BTCUSD").symbol

The AddCrypto add_crypto method creates a subscription for a single Crypto asset and adds it to your user-defined universe. To create a dynamic universe of Crypto assets, add a Crypto universe .

To view the supported assets, see the CoinAPI datasets .

Fungible Assets

Fungible assets are assets that are interchangeable with each other. For example, every Bitcoin is effectively identical to every other Bitcoin. In contrast, non-fungible tokens (NFTs) are non-fungible because each one is unique. An example of an NFT is the Bored Ape Yacht Club collection. LEAN doesn't currently support trading NFTs.

Resolutions

The following table shows the available resolutions and data formats for Crypto subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick TICK
Second SECOND
Minute MINUTE
Hour HOUR
Daily DAILY

The default resolution for Crypto subscriptions is Resolution.Minute Resolution.MINUTE . To change the resolution, pass a resolution argument to the AddCrypto add_crypto method.

_symbol = AddCrypto("BTCUSD", Resolution.Daily).Symbol;

self._symbol = self.add_crypto("BTCUSD", Resolution.DAILY).symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

The following Market enumeration members are available for Crypto:

To set the market for a security, pass a market argument to the AddCrypto add_crypto method.

_symbol = AddCrypto("BTCUSD", market: Market.Coinbase).Symbol;

self._symbol = self.add_crypto("BTCUSD", market=Market.COINBASE).symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

_symbol = AddCrypto("BTCUSD", fillForward: false).Symbol;

self._symbol = self.add_crypto("BTCUSD", fill_forward=False).symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of leverage available to you depends on the brokerage you use. To change the amount of leverage you can use for a security, pass a leverage argument to the AddCrypto add_crypto method.

_symbol = AddCrypto("BTCUSD", leverage: 3).Symbol;

self._symbol = self.add_crypto("BTCUSD", leverage=3).symbol

For more information about the leverage each brokerage provides, see Brokerages .

Data Normalization

The data normalization mode doesn't affect the data that LEAN passes to OnData on_data or the data from history request . If you change the data normalization mode, it won't change the outcome.

Properties

The AddCrypto add_crypto method returns a Crypto object, which have the following properties:

Securities > Asset Classes > Crypto > Handling Data

Introduction

LEAN passes the data you request to the OnData on_data method so you can make trading decisions. The default OnData on_data method accepts a Slice object, but you can define additional OnData on_data methods that accept different data types. For example, if you define an OnData on_data method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData on_data method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData on_data method, use the CurrentSlice current_slice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol symbol , but we recommend you use the Symbol symbol .

To view the resolutions that are available for Crypto data, see Resolutions .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars bars property of the Slice with the security Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    trade_bar = slice.bars.get(self._symbol)   # None if not found

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        close_price = trade_bar.close

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open open , High high , Low low , and Close close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open open , High high , Low low , and Close close properties of the QuoteBar copy the values of either the Bid bid or Ask ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the security Symbol symbol . If the security doesn't actively get quotes or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    quote_bar = slice.quote_bars.get(self._symbol)   # None if not found

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.quote_bars.items():
        ask_price = quote_bar.ask.close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the security. A quote tick is an offer to buy or sell the security at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity quantity and Price price properties, but they have a zero value for the BidPrice bid_price , BidSize bid_size , AskPrice ask_price , and AskSize ask_size properties. Quote ticks have non-zero values for BidPrice bid_price and BidSize bid_size properties or have non-zero values for AskPrice ask_price and AskSize ask_size properties. To check if a tick is a trade or a quote, use the TickType ticktype property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    ticks = slice.ticks.get(self._symbol, [])   # Empty if not found
    for tick in ticks:
        price = tick.price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            price = tick.price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

Securities > Asset Classes > Crypto > Holdings

Introduction

Crypto holdings require special consideration because not all brokerages track your positions in each currency pair.

Cash vs Margin Brokerage Accounts

Some of the Crypto brokerages integrated into QuantConnect support cash and margin accounts while some only support cash accounts. If you want to short Crypto assets or use leverage, you need a margin account. Follow these steps to view which account types each brokerage supports:

1. Open the brokerage guides .
2. Click a Crypto brokerage.
3. Scroll down to the Account Types section.

Virtual Pairs

All fiat and Crypto currencies are individual assets. When you buy a pair like BTCUSD, you trade USD for BTC. In this case, LEAN removes some USD from your portfolio cashbook and adds some BTC. The virtual pair BTCUSD represents your position in that trade, but the virtual pair doesn't actually exist. It simply represents an open trade. If you call the Liquidate method with the Symbol symbol of a virtual pair, the method only liquidates the quantity in your virtual pair. For more information about liquidating Crypto postitions, see Crypto Trades .

Access Cypto Holdings

The CashBook cash_book stores the quantity of your Crypto holdings. To access your Crypto holdings, index the CashBook cash_book with the currency ticker. The values of the CashBook dictionary are Cash objects, which have the following properties:

var btcQuantity = Portfolio.CashBook["BTC"].Amount;
var btcValue = Portfolio.CashBook["BTC"].ValueInAccountCurrency;

btc_quantity = self.portfolio.cash_book['BTC'].amount
btc_value = self.portfolio.cash_book['BTC'].value_in_account_currency

To access the virtual pair of your Crypto trades, index the Portfolio portfolio object with the pair Symbol symbol .

var securityHolding = Portfolio[_btcUsdSymbol];

security_holding  = self.portfolio[self._btc_usd_symbol]

Stateful Redeployments

When you make a trade inside of a running algorithm, LEAN tracks the virtual position state for you, but it won't survive between deployments. Some brokerages save your virtual pairs, so you can load them into your algorithm when you stop and redeploy it. Depending on the brokerage you select, you may be able to manually add virtual pairs when you deploy live algorithms with the LEAN CLI or cloud deployment wizard .

Securities > Asset Classes > Crypto > Market Hours

Introduction

The Crypto markets are open 24/7. There are no pre-market hours, post-market hours, holidays, late opens, or early closes.

Securities > Asset Classes > Crypto Futures

Securities > Asset Classes > Crypto Futures > Requesting Data

Introduction

Request Crypto Futures data in your algorithm to receive a feed of asset prices in the OnData on_data method. For more information about the specific datasets we use for backtests, see the Binance Crypto Future Price Data dataset listing . To trade Crypto Futures live, you can use the QuantConnect data provider .

Create Subscriptions

To create a Crypto Futures subscription, in the Initialize initialize method, call the AddCryptoFuture add_crypto_future method. The AddCryptoFuture add_crypto_future method returns a CryptoFuture object, which contains a Symbol symbol property. Save a reference to the Symbol symbol so you can use it in OnData on_data to access the security data in the Slice .

_symbol = AddCryptoFuture("BTCUSD").Symbol;

self._symbol = self.add_crypto_future("BTCUSD").symbol

The AddCryptoFuture add_crypto_future method creates a subscription for a single Crypto Futures asset and adds it to your user-defined universe.

To view the supported assets in the Crypto Futures dataset, see Supported Assets .

Resolutions

The following table shows the available resolutions and data formats for Crypto Futures contract subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick TICK
Second SECOND
Minute MINUTE
Hour HOUR
Daily DAILY

The default resolution for Crypto Futures subscriptions is Resolution.Minute Resolution.MINUTE . To change the resolution, pass a resolution argument to the AddCryptoFuture add_crypto_future method.

_symbol = AddCryptoFuture("BTCUSD", Resolution.Daily).Symbol;

self._symbol = self.add_crypto_future("BTCUSD", Resolution.DAILY).symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

Crypto Futures are currently only available on Market.Binance Market.BINANCE . To set the market for a security, pass a market argument to the AddCryptoFuture add_crypto_future method.

_symbol = AddCryptoFuture("BTCUSD", market: Market.Binance).Symbol;

self._symbol = self.add_crypto_future("BTCUSD", market=Market.BINANCE).symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

_symbol = AddCryptoFuture("BTCUSD", fillForward: false).Symbol;

self._symbol = self.add_crypto_future("BTCUSD", fill_forward=False).symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of leverage available to you depends on the brokerage you use. To change the amount of leverage you can use for a security, pass a leverage argument to the AddCryptoFuture add_crypto_future method.

_symbol = AddCryptoFuture("BTCUSD", leverage: 3).Symbol;

self._symbol = self.add_crypto_future("BTCUSD", leverage=3).symbol

For more information about the leverage each brokerage provides, see Brokerages .

Data Normalization

The data normalization mode doesn't affect the data that LEAN passes to OnData on_data or the data from history request . If you change the data normalization mode, it won't change the outcome.

Properties

The AddCryptoFuture add_crypto_future method returns a CryptoFuture object, which have the following properties:

Securities > Asset Classes > Crypto Futures > Handling Data

Introduction

LEAN passes the data you request to the OnData on_data method so you can make trading decisions. The default OnData on_data method accepts a Slice object, but you can define additional OnData on_data methods that accept different data types. For example, if you define an OnData on_data method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData on_data method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData on_data method, use the CurrentSlice current_slice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol symbol , but we recommend you use the Symbol symbol .

To view the resolutions that are available for Crypto Futures data, see Resolutions .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars bars property of the Slice with the security Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    trade_bar = slice.bars.get(self._symbol)   # None if not found

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        close_price = trade_bar.close

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open open , High high , Low low , and Close close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open open , High high , Low low , and Close close properties of the QuoteBar copy the values of either the Bid bid or Ask ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the security Symbol symbol . If the security doesn't actively get quotes or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    quote_bar = slice.quote_bars.get(self._symbol)   # None if not found

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.quote_bars.items():
        ask_price = quote_bar.ask.close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the security. A quote tick is an offer to buy or sell the security at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity quantity and Price price properties, but they have a zero value for the BidPrice bid_price , BidSize bid_size , AskPrice ask_price , and AskSize ask_size properties. Quote ticks have non-zero values for BidPrice bid_price and BidSize bid_size properties or have non-zero values for AskPrice ask_price and AskSize ask_size properties. To check if a tick is a trade or a quote, use the TickType ticktype property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    ticks = slice.ticks.get(self._symbol, [])   # Empty if not found
    for tick in ticks:
        price = tick.price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            price = tick.price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

Margin Interest Rates

MarginInterestRate objects contain the margin interest rate, which is a cost associated with trading on margin. MarginInterestRate objects have the following properties:

To get the MarginInterestRate margin_interest_rate objects in the Slice , index the MarginInterestRate margin_interest_rate property of the Slice with the Crypto Future Symbol . The MarginInterestRate margin_interest_rate property of the Slice may not contain data for your Symbol . To avoid issues, check if the property contains data for your Crypto Future before you index it with the Crypto Future Symbol .

public override void OnData(Slice slice)
{
    if (slice.MarginInterestRates.ContainsKey(_symbol))
    {
        var interestRate = slice.MarginInterestRates[_symbol].InterestRate;
    }
}

def on_data(self, slice: Slice) -> None:
    margin_interest_rate = slice.margin_interest_rate.get(self._symbol)
    if margin_interest_rate:
        interest_rate = margin_interest_rate.interest_rate

You can also iterate through the MarginInterestRate margin_interest_rate dictionary. The keys of the dictionary are the Symbol objects and the values are the MarginInterestRate margin_interest_rate objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.MarginInterestRates)
    {
        var symbol = kvp.Key;
        var marginInterestRate = kvp.Value;
        var interestRate = marginInterestRate.InterestRate;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, margin_interest_rate in slice.MarginInterestRates.items():
        interest_rate = margin_interest_rate.interest_rate

Securities > Asset Classes > Crypto Futures > Market Hours

Introduction

The Crypto Futures markets are open 24/7. There are no pre-market hours, post-market hours, holidays, late opens, or early closes.

Securities > Asset Classes > Forex

Securities > Asset Classes > Forex > Requesting Data

Introduction

Request Forex data in your algorithm to receive a feed of exchange rates in the OnData on_data method. For more information about the specific dataset we use for backtests, see the FOREX dataset listing . To trade Forex live, you can use the QuantConnect data provider .

Create Subscriptions

To create a Forex pair subscription, in the Initialize initialize method, call the AddForex add_forex method. The AddForex add_forex method returns a Forex object, which contains a Symbol symbol property. Save a reference to the Symbol symbol so you can use it in OnData on_data to access the security data in the Slice .

_symbol = AddForex("EURUSD").Symbol;

self._symbol = self.add_forex("EURUSD").symbol

To view the supported Forex pairs, see Supported Assets .

Resolutions

The following table shows the available resolutions and data formats for Forex subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick TICK
Second SECOND
Minute MINUTE
Hour HOUR
Daily DAILY

The default resolution for Forex subscriptions is Resolution.Minute Resolution.MINUTE . To change the resolution, pass a resolution argument to the AddForex add_forex method.

_symbol = AddForex("EURUSD", Resolution.Daily).Symbol;

self._symbol = self.add_forex("EURUSD", Resolution.DAILY).symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

The only market available for Forex pairs is Market.Oanda Market.OANDA , so you don't need to pass a market argument to the AddForex add_forex method.

_symbol = AddForex("EURUSD", market: Market.Oanda).Symbol;

self._symbol = self.add_forex("EURUSD", market=Market.OANDA).symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward fill_forward argument to false when you create the security subscription.

_symbol = AddForex("EURUSD", fillForward: false).Symbol;

self._symbol = self.add_forex("EURUSD", fill_forward=False).symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The Oanda brokerage let's you use up to 50x leverage on margin accounts. To change the amount of leverage you can use for a Forex pair, pass a leverage argument to the AddForex add_forex method.

_symbol = AddForex("EURUSD", leverage: 35).Symbol;

self._symbol = self.add_forex("EURUSD", leverage=35).symbol

Data Normalization

The data normalization mode doesn't affect the data that LEAN passes to OnData on_data or the data from history request . If you change the data normalization mode, it won't change the outcome.

Properties

The AddForex add_forex method returns a Forex object, which have the following properties:

Securities > Asset Classes > Forex > Handling Data

Introduction

LEAN passes the data you request to the OnData on_data method so you can make trading decisions. The default OnData on_data method accepts a Slice object, but you can define additional OnData on_data methods that accept different data types. For example, if you define an OnData on_data method that accepts a QuoteBar argument, it only receives QuoteBar objects. The Slice object that the OnData on_data method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData on_data method, use the CurrentSlice current_slice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the QuoteBars DataDictionary is made up of QuoteBar objects. To access individual data points in the dictionary, you can index the dictionary with the Forex pair ticker or Symbol symbol , but we recommend you use the Symbol symbol .

To view the resolutions that are available for Forex data, see Resolutions .

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open open , High high , Low low , and Close close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open open , High high , Low low , and Close close properties of the QuoteBar copy the values of either the Bid bid or Ask ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the Forex pair Symbol symbol . If the Forex pair doesn't actively get quotes or you are in the same time step as when you added the Forex pair subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your Forex pair before you index the Slice with the Forex pair Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    quote_bar = slice.quote_bars.get(self._symbol)   # None if not found

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.quote_bars.items():
        ask_price = quote_bar.ask.close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the Forex pair. A quote tick is an offer to buy or sell the Forex pair at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity quantity and Price price properties, but they have a zero value for the BidPrice bid_price , BidSize bid_size , AskPrice ask_price , and AskSize ask_size properties. Quote ticks have non-zero values for BidPrice bid_price and BidSize bid_size properties or have non-zero values for AskPrice ask_price and AskSize ask_size properties. To check if a tick is a trade or a quote, use the TickType ticktype property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol symbol . If the Forex pair doesn't actively trade or you are in the same time step as when you added the Forex pair subscription, the Slice may not contain data for your Symbol symbol . To avoid issues, check if the Slice contains data for your Forex pair before you index the Slice with the Forex pair Symbol symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    ticks = slice.ticks.get(self._symbol, [])   # Empty if not found
    for tick in ticks:
        price = tick.price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            price = tick.price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

Securities > Asset Classes > Forex > Market Hours

Introduction

This page shows the trading hours, holidays, and time zone of the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the Forex market:

Early Closes

The following table shows the early closes for the Forex market:

Late Opens

The following table shows the late opens for the Forex market:

Time Zone

The Forex market trades in the America/New York time zone.

Assets With Other Hours

The following list shows the pairs that have different trading periods than the overall Forex market:

• EURNZD
• GBPNZD
• NZDCAD
• NZDCHF
• NZDHKD
• NZDJPY
• NZDSGD
• NZDUSD

Securities > Asset Classes > Forex > Market Hours > EURNZD

Introduction

This page shows the trading hours, holidays, and time zone of the EUR/NZD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the EUR/NZD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the EUR/NZD pair in the Forex market:

Early Closes

The following table shows the early closes for the EUR/NZD pair in the Forex market: